private async Task Tick(CancellationToken cancellationToken)
        {
            var eventMapping = new EventMapping(EventMapping.DiscoverEventNamesInAssembly(typeof(ClockHasTicked).Assembly));

            var clockStreamId      = new StreamId(ClockStreamId);
            var lastClockHasTicked = await _streamStore.ReadStreamBackwards(
                streamId : clockStreamId,
                fromVersionInclusive : StreamVersion.End,
                maxCount : 1,
                prefetchJsonData : true,
                cancellationToken : cancellationToken);

            if (!lastClockHasTicked.Messages.Any())
            {
                await AppendClockHasTicked(cancellationToken, clockStreamId, eventMapping);
            }
            else
            {
                var lastClockTickJsonData = await lastClockHasTicked.Messages[0].GetJsonData(cancellationToken);
                var lastClockTick         = JsonConvert.DeserializeObject <ClockHasTicked>(lastClockTickJsonData);

                if (LocalDate.FromDateTime(lastClockTick.DateTime.Date) != _clockProvider.Today)
                {
                    await AppendClockHasTicked(cancellationToken, clockStreamId, eventMapping);
                }
            }
        }
예제 #2
0
        public ExampleAggregateCommandHandlerModule(
            Func <IStreamStore> getStreamStore,
            Func <ConcurrentUnitOfWork> getUnitOfWork,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            Func <IExampleAggregates> getExampleAggregates)
        {
            For <NameExampleAggregate>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .Handle(async(message, ct) =>
            {
                var exampleAggregates = getExampleAggregates();

                var exampleAggregateId       = message.Command.ExampleAggregateId;
                var possibleExampleAggregate = await exampleAggregates.GetOptionalAsync(exampleAggregateId, ct);

                if (!possibleExampleAggregate.HasValue)
                {
                    possibleExampleAggregate = new Optional <ExampleAggregate>(ExampleAggregate.Register(exampleAggregateId));
                    exampleAggregates.Add(exampleAggregateId, possibleExampleAggregate.Value);
                }

                var exampleAggregate = possibleExampleAggregate.Value;

                exampleAggregate.NameExampleAggregate(message.Command.ExampleAggregateName);
            });
        }
예제 #3
0
        public void event_name_for_event_type()
        {
            var options = new StoreOptions();
            var mapping = new EventMapping <MembersJoined>(new EventGraph(options));

            mapping.EventTypeName.ShouldBe("members_joined");
        }
        protected override Task Context()
        {
            _parameterMapper     = A.Fake <ParameterMapper>();
            _eventMappingFactory = A.Fake <IEventMappingFactory>();
            sut = new EventMappingMapper(_parameterMapper, _eventMappingFactory);

            _event = new PKSimEvent()
                     .WithName("E1")
                     .WithId("EventId");

            _eventMapping = new EventMapping
            {
                TemplateEventId = _event.Id,
                StartTime       = DomainHelperForSpecs.ConstantParameterWithValue(1)
            };

            _snapshotEventStartTime1 = new Parameter {
                Name = "P1"
            };

            _project = new PKSimProject();
            _project.AddBuildingBlock(_event);
            A.CallTo(() => _parameterMapper.MapToSnapshot(_eventMapping.StartTime)).Returns(_snapshotEventStartTime1);

            return(_completed);
        }
예제 #5
0
        private static async Task <long> AddSqlStreamStore(
            Func <IStreamStore> getStreamStore,
            Func <ConcurrentUnitOfWork> getUnitOfWork,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            CommandMessage message,
            CancellationToken ct)
        {
            var aggregate = getUnitOfWork().GetChanges().SingleOrDefault();

            if (aggregate == null)
            {
                return(-1L);
            }

            if (!message.Metadata.ContainsKey("CommandId"))
            {
                message.Metadata.Add("CommandId", message.CommandId);
            }

            var i      = 1;
            var result = await getStreamStore().AppendToStream(
                aggregate.Identifier,
                aggregate.ExpectedVersion,
                aggregate.Root.GetChangesWithMetadata()
                .Select(o =>
                        new NewStreamMessage(
                            messageId: Deterministic.Create(Deterministic.Namespaces.Events, $"{message.CommandId}-{i++}"),
                            type: eventMapping.GetEventName(o.Event.GetType()),
                            jsonData: eventSerializer.SerializeObject(o.Event),
                            jsonMetadata: eventSerializer.SerializeObject(GetMetadata(message.Metadata, o.Metadata))))
                .ToArray(), ct);

            return(result.CurrentPosition);
        }
예제 #6
0
        public PostalInformationCommandHandlerModule(
            Func <IPostalInformationSet> getPostalInformationSet,
            Func <ConcurrentUnitOfWork> getUnitOfWork,
            Func <IStreamStore> getStreamStore,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            BPostPostalInformationProvenanceFactory bpostProvenanceFactory,
            CrabPostalInformationProvenanceFactory crabProvenanceFactory)
        {
            For <ImportPostalInformationFromBPost>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .AddProvenance(getUnitOfWork, bpostProvenanceFactory)
            .Handle(async(message, ct) =>
            {
                var postalCode           = message.Command.PostalCode;
                var postalInformationSet = getPostalInformationSet();
                var postalInformation    = await postalInformationSet.GetOptionalAsync(postalCode, ct);

                if (!postalInformation.HasValue)
                {
                    postalInformation = new Optional <PostalInformation>(PostalInformation.Register(postalCode));
                    postalInformationSet.Add(postalCode, postalInformation.Value);
                }

                postalInformation.Value.ImportPostalInformationFromBPost(
                    message.Command.PostalCode,
                    message.Command.PostalNames,
                    message.Command.IsSubMunicipality,
                    message.Command.Province,
                    message.Command.Modification);
            });

            For <ImportPostalInformationFromCrab>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .AddProvenance(getUnitOfWork, crabProvenanceFactory)
            .Handle(async(mesage, ct) =>
            {
                // need to use the subcanton => in crab postcode = 1030, subcanton = 1031
                // in bpost postcode = 1031
                var postalCode        = new PostalCode(mesage.Command.SubCantonCode);
                var postalInformation = await getPostalInformationSet().GetOptionalAsync(postalCode, ct);

                if (!postalInformation.HasValue)     // Crab has possible outdated postalcodes
                {
                    return;
                }

                postalInformation.Value.ImportPostalInformationFromCrab(
                    mesage.Command.PostalCode,
                    mesage.Command.SubCantonId,
                    mesage.Command.SubCantonCode,
                    mesage.Command.NisCode,
                    mesage.Command.MunicipalityName,
                    mesage.Command.Lifetime,
                    mesage.Command.Timestamp,
                    mesage.Command.Operator,
                    mesage.Command.Modification,
                    mesage.Command.Organisation);
            });
        }
예제 #7
0
        public IdempotentCommandHandlerModuleProcessor(
            Func <IAddresses> getAddresses,
            ConcurrentUnitOfWork concurrentUnitOfWork,
            IPersistentLocalIdGenerator persistentLocalIdGenerator,
            Func <IStreamStore> getStreamStore,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            AddressProvenanceFactory addressProvenanceFactory,
            CrabAddressProvenanceFactory crabProvenanceFactory,
            AddressPersistentLocalIdentifierProvenanceFactory addressPersistentLocalIdentifierProvenanceFactory)
        {
            _getAddresses         = getAddresses;
            _concurrentUnitOfWork = concurrentUnitOfWork;
            _provenanceFactory    = crabProvenanceFactory.CreateFrom;
            _addressPersistentLocalIdProvenanceFactory = addressPersistentLocalIdentifierProvenanceFactory.CreateFrom;

            _addressCommandHandlerModule = new AddressCommandHandlerModule(
                _getAddresses,
                () => concurrentUnitOfWork,
                persistentLocalIdGenerator,
                getStreamStore,
                eventMapping,
                eventSerializer,
                addressProvenanceFactory,
                crabProvenanceFactory,
                addressPersistentLocalIdentifierProvenanceFactory);
        }
예제 #8
0
 private static void PublishToConsumer <T>(IConsumer <T> x, T eventMessage) where T : IEventMessage
 {
     if (x is DummyConsumer <T> )
     {
         return;
     }
     if (x is ESBConsumer <T> )
     {
         EventMapping.AddEvent <T>(eventMessage.Subject);
     }
     if (x.ExecuteMode == ExecuteMode.Sync ||
         (x.ExecuteMode == ExecuteMode.AccordingToTransaction && Transaction.Current != null))
     // 同步执行
     {
         x.HandleEvent(eventMessage);
     }
     else // 异步执行
     {
         Action <T> act = new Action <T>(x.HandleEvent);
         act.BeginInvoke(eventMessage, ar =>
         {
             Action <T> tmp = ar.AsyncState as Action <T>;
             if (tmp != null)
             {
                 tmp.EndInvoke(ar);
             }
         }, act);
     }
 }
        public DomainCommandHandlerModule(
            Func <IStreamStore> getStreamStore,
            Func <ConcurrentUnitOfWork> getUnitOfWork,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            Func <IDomains> getDomains)
        {
            For <CreateDomain>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .Handle(async(message, ct) =>
            {
                var domains = getDomains();

                var domainName = message.Command.DomainName;
                var domain     = Domain.Register(domainName);

                domains.Add(domainName, domain);
            });

            For <AddManual>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .Handle(async(message, ct) =>
            {
                var domains = getDomains();

                var domainName = message.Command.DomainName;
                var domain     = await domains.GetAsync(domainName, ct);

                domain.AddManual(
                    message.Command.ServiceId,
                    message.Command.Label,
                    message.Command.Records);
            });

            For <AddGoogleSuite>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .Handle(async(message, ct) =>
            {
                var domains = getDomains();

                var domainName = message.Command.DomainName;
                var domain     = await domains.GetAsync(domainName, ct);

                domain.AddGoogleSuite(
                    message.Command.ServiceId,
                    message.Command.VerificationToken);
            });

            For <RemoveService>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .Handle(async(message, ct) =>
            {
                var domains = getDomains();

                var domainName = message.Command.DomainName;
                var domain     = await domains.GetAsync(domainName, ct);

                domain.RemoveService(message.Command.ServiceId);
            });
        }
 public RoadNetworkChangesArchives(EventSourcedEntityMap map, IStreamStore store, JsonSerializerSettings settings, EventMapping mapping)
 {
     _map      = map ?? throw new ArgumentNullException(nameof(map));
     _store    = store ?? throw new ArgumentNullException(nameof(store));
     _settings = settings ?? throw new ArgumentNullException(nameof(settings));
     _mapping  = mapping ?? throw new ArgumentNullException(nameof(mapping));
 }
예제 #11
0
        public void SetUp()
        {
            _model = new Model();

            var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
            var eventSerializer   = new EventSerializer(SimpleJson.SerializeObject);
            var eventMapping      = new EventMapping(new Dictionary <string, Type>
            {
                { typeof(SnapshotStub).AssemblyQualifiedName, typeof(SnapshotStub) },
                { typeof(EventStub).AssemblyQualifiedName, typeof(EventStub) },
            });

            var snapshotContainer = new SnapshotContainer
            {
                Info =
                {
                    Position = 4,
                    Type     = typeof(SnapshotStub).AssemblyQualifiedName
                },
                Data = eventSerializer.SerializeObject(new SnapshotStub(1))
            };

            _sut = new RepositoryScenarioBuilder(eventMapping, eventDeserializer)
                   .ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(0))
                   .ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1))
                   .ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(2))
                   .ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(3))
                   .ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(4))
                   .ScheduleAppendToStream($"{_model.KnownIdentifier}-snapshots", snapshotContainer)
                   .ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(5))
                   .ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(6))
                   .BuildForRepository <AggregateRootEntitySnapshotableStub>();
        }
예제 #12
0
        private Func <TestMessage, Task <AppendResult> > CreateMessageStorerAndStartHandling(ConnectedProjection <TestDbContext> projection)
        {
            var eventMapping =
                new EventMapping(EventMapping.DiscoverEventNamesInAssembly(typeof(RunnerTests).Assembly));
            var testRunner =
                new TestRunner(
                    new EnvelopeFactory(
                        eventMapping,
                        new EventDeserializer(JsonConvert.DeserializeObject)),
                    new Logger <TestRunner>(new LoggerFactory()),
                    projection);

            var options = new DbContextOptionsBuilder <TestDbContext>()
                          .UseInMemoryDatabase("testing")
                          .Options;

            using (var testDbContext = new TestDbContext(options))
            {
                testDbContext.Database.EnsureDeleted();
            }

            var inMemoryStreamStore = new InMemoryStreamStore(() => DateTime.UtcNow);

            testRunner.Handle(
                inMemoryStreamStore,
                () => new Owned <TestDbContext>(new TestDbContext(options), this));

            return(async message => await inMemoryStreamStore.AppendToStream(new StreamId("Bla"), ExpectedVersion.Any,
                                                                             new NewStreamMessage(Guid.NewGuid(), eventMapping.GetEventName(typeof(TestMessage)), JsonConvert.SerializeObject(message))));
        }
예제 #13
0
        public IdempotentCommandHandlerModuleProcessor(
            Func <IParcels> getParcels,
            IParcelFactory parcelFactory,
            ConcurrentUnitOfWork concurrentUnitOfWork,
            Func <IStreamStore> getStreamStore,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            ParcelProvenanceFactory provenanceFactory)
        {
            _getParcels           = getParcels;
            _parcelFactory        = parcelFactory;
            _concurrentUnitOfWork = concurrentUnitOfWork;
            _provenanceFactory    = provenanceFactory.CreateFrom;

            var fixGrar1475ProvenanceFactory = new FixGrar1475ProvenanceFactory();

            _fixGrar1475ProvenanceFactory = fixGrar1475ProvenanceFactory.CreateFrom;

            var fixGrar1637ProvenanceFactory = new FixGrar1637ProvenanceFactory();

            _fixGrar1637ProvenanceFactory = fixGrar1637ProvenanceFactory.CreateFrom;

            _parcelCommandHandlerModule = new ParcelCommandHandlerModule(
                getParcels,
                parcelFactory,
                () => concurrentUnitOfWork,
                getStreamStore,
                eventMapping,
                eventSerializer,
                provenanceFactory,
                fixGrar1475ProvenanceFactory,
                fixGrar1637ProvenanceFactory);
        }
        public AccountCommandHandlerModule(
            Func <IStreamStore> getStreamStore,
            Func <ConcurrentUnitOfWork> getUnitOfWork,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            Func <IAccounts> getAccounts)
        {
            For <NameAccount>()
            .AddSqlStreamStore(getStreamStore, getUnitOfWork, eventMapping, eventSerializer)
            .Handle(async(message, ct) =>
            {
                var accounts = getAccounts();

                var accountId       = message.Command.AccountId;
                var possibleAccount = await accounts.GetOptionalAsync(accountId, ct);

                if (!possibleAccount.HasValue)
                {
                    possibleAccount = new Optional <Account>(Account.Register(accountId));
                    accounts.Add(accountId, possibleAccount.Value);
                }

                var account = possibleAccount.Value;

                account.NameAccount(message.Command.AccountName);
            });
        }
예제 #15
0
        public void ConfigureServices(IServiceCollection services)
        {
            PrometheusMetrics.TryConfigure(Environment.ApplicationName);
            EventMapping.Map();

            var esConnection = ConfigureEsConnection(
                Configuration["EventStore:ConnectionString"],
                Environment.ApplicationName);
            var documentStore = ConfigureRavenDb(
                Configuration["RavenDb:Server"],
                Configuration["RavenDb:Database"]
                );

            var ravenDbStore = new RavenDBProvider(documentStore);

            services.AddSingleton(c => (Func <IAsyncDocumentSession>)GetSession);
            services.AddSingleton <IHostedService>(
                new EventStoreService(
                    esConnection,
                    Props.FromProducer(() =>
                                       new SubscriptionActor(
                                           esConnection,
                                           new RavenDbCheckpointStore(GetSession, "readmodels"),
                                           "ravenDbSubscription",
                                           (Props.FromProducer(
                                                () => new CustomerVehiclesProjection(ravenDbStore)), "customerVehicles"),
                                           (Props.FromProducer(
                                                () => new VehicleItemProjection(ravenDbStore)), "vehicleItems")
                                           )
                                       )
                    )
                );

            IAsyncDocumentSession GetSession() => documentStore.OpenAsyncSession();
        }
예제 #16
0
        public void CreateDependencies()
        {
            var store        = new InMemoryStreamStore();
            var eventMapping = new EventMapping(new Dictionary <string, Type>
            {
                { "SomethingHappened", typeof(SomethingHappened) },
                { "SomethingElseHappened", typeof(SomethingElseHappened) },
            });
            var eventSerializer   = new EventSerializer(JsonConvert.SerializeObject);
            var eventDeserializer = new EventDeserializer(JsonConvert.DeserializeObject);

            _factRepository = new StreamStoreFactRepository(store, eventMapping, eventSerializer, eventDeserializer);

            _handlerFactory = (eventType, @events) =>
                              async(command) =>
            {
                long position = 0;
                foreach (var @event in events)
                {
                    position = (await store.AppendToStream(
                                    (command as DoSomething).Identifier,
                                    ExpectedVersion.Any,
                                    new NewStreamMessage(Guid.NewGuid(), eventType,
                                                         eventSerializer.SerializeObject(@event)),
                                    CancellationToken.None)
                                ).CurrentPosition;
                }

                return(position);
            };
            _handlerResolver = new Mocking <IHandlerResolver, HandlerResolverSetup>();
            //_handlerResolver.When().ResolvesHandler(_handlerFactory);
        }
        public void SqlServerEventStore_RetrieveEvents_PlainEvent_Should_Work()
        {
            var eventStore = new SqlServerEventStore(this.Settings, this.EventDispatcher);

            var aggId = Guid.NewGuid();

            var events = new[]
            {
                new PlainEvent(aggId, PlainEvent.TestEnum.Nope),
                new PlainEvent(aggId, null),
                new PlainEvent(Guid.NewGuid(), null),
                new PlainEvent(aggId, PlainEvent.TestEnum.Ok),
            };

            var eventsCount = events.Count(e => e.MyAggId == aggId);

            foreach (var @event in events)
            {
                eventStore.Save(@event);
            }

            var eventMapping = new EventMapping {
                AggregateIdPropertyName = nameof(PlainEvent.MyAggId), EventType = typeof(PlainEvent)
            };

            var eventDescriptors = new[] { eventMapping };

            var savedEvents = eventStore.RetrieveEvents(aggId, DateTime.Now, eventDescriptors, timelineId: null);

            Assert.NotNull(savedEvents);
            Assert.NotEmpty(savedEvents);
            Assert.True(savedEvents.All(e => e is PlainEvent));

            Assert.Equal(eventsCount, savedEvents.Count());
        }
        private static async Task <long> AddSqlStreamStore(
            Func <IStreamStore> getStreamStore,
            Func <ConcurrentUnitOfWork> getUnitOfWork,
            EventMapping eventMapping,
            EventSerializer eventSerializer,
            CommandMessage message,
            CancellationToken ct)
        {
            var uow = getUnitOfWork();

            var aggregate = uow.GetChanges().SingleOrDefault();

            if (aggregate == null)
            {
                return(-1L);
            }

            var streamStore = getStreamStore();

            if (!message.Metadata.ContainsKey("CommandId"))
            {
                message.Metadata.Add("CommandId", message.CommandId);
            }

            var i = 1;

            var events  = aggregate.Root.GetChangesWithMetadata().ToImmutableList();
            var changes = events
                          .Select(o =>
                                  new NewStreamMessage(
                                      messageId: Deterministic.Create(Deterministic.Namespaces.Events, $"{message.CommandId}-{i++}"),
                                      type: eventMapping.GetEventName(o.Event.GetType()),
                                      jsonData: eventSerializer.SerializeObject(o.Event),
                                      jsonMetadata: eventSerializer.SerializeObject(GetMetadata(message.Metadata, o.Metadata))))
                          .ToArray();

            var result = await streamStore.AppendToStream(
                aggregate.Identifier,
                aggregate.ExpectedVersion,
                changes,
                ct);

            if (aggregate.Root is ISnapshotable support)
            {
                await CreateSnapshot(
                    support,
                    new SnapshotStrategyContext(
                        aggregate,
                        events,
                        result.CurrentPosition),
                    streamStore,
                    uow,
                    eventMapping,
                    eventSerializer,
                    ct);
            }

            return(result.CurrentPosition); // Position of the last event written
        }
예제 #19
0
        public void SetUp()
        {
            var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
            var eventMapping      = new EventMapping(new Dictionary <string, Type>());

            _model = new Model();
            _sut   = new RepositoryScenarioBuilder(eventMapping, eventDeserializer).BuildForRepository();
        }
예제 #20
0
        private void PhaseChangedSlot(object[] parameters)
        {
            DraggableItem item    = (DraggableItem)parameters[0];
            EventMapping  mapping = (EventMapping)item.Data;

            //Debug.Log(string.Format("PhaseChangedSlot: {0}", mapping));
            EventMappingDescriptor.ProcessPhases(Adapter, null, mapping, mapping.Enabled);
        }
예제 #21
0
 public ScenarioRunner(CommandHandlerResolver resolver, IStreamStore store, JsonSerializerSettings settings, EventMapping mapping, StreamNameConverter converter)
 {
     _resolver  = resolver ?? throw new ArgumentNullException(nameof(resolver));
     _store     = store ?? throw new ArgumentNullException(nameof(store));
     _settings  = settings ?? throw new ArgumentNullException(nameof(settings));
     _mapping   = mapping ?? throw new ArgumentNullException(nameof(mapping));
     _converter = converter ?? throw new ArgumentNullException(nameof(converter));
 }
예제 #22
0
 public void SetUp()
 {
     _store             = new InMemoryStreamStore(() => DateTime.UtcNow);
     _unitOfWork        = new ConcurrentUnitOfWork();
     _factory           = AggregateRootEntityStub.Factory;
     _eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
     _eventMapping      = new EventMapping(new Dictionary <string, Type>());
 }
예제 #23
0
 public Repository(
     Func <TAggregateRoot> factory,
     ConcurrentUnitOfWork unitOfWork,
     IStreamStore eventStore,
     EventMapping eventMapping,
     EventDeserializer eventDeserializer)
     : base(factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
 {
 }
 public RepositoryScenarioBuilder(EventMapping eventMapping, EventDeserializer eventDeserializer)
 {
     _eventStore         = new InMemoryStreamStore(() => DateTime.UtcNow);
     _unitOfWork         = new ConcurrentUnitOfWork();
     _eventStoreSchedule = new List <Action <IStreamStore> >();
     _unitOfWorkSchedule = new List <Action <ConcurrentUnitOfWork> >();
     _eventMapping       = eventMapping;
     _eventDeserializer  = eventDeserializer;
 }
예제 #25
0
 public RoadNetworks(EventSourcedEntityMap map, IStreamStore store, IRoadNetworkSnapshotReader snapshotReader,
                     JsonSerializerSettings settings, EventMapping mapping)
 {
     _map            = map ?? throw new ArgumentNullException(nameof(map));
     _store          = store ?? throw new ArgumentNullException(nameof(store));
     _settings       = settings ?? throw new ArgumentNullException(nameof(settings));
     _mapping        = mapping ?? throw new ArgumentNullException(nameof(mapping));
     _snapshotReader = snapshotReader ?? throw new ArgumentNullException(nameof(snapshotReader));
 }
 public StreamStoreFactRepository(
     IStreamStore streamStore,
     EventMapping eventMapping,
     EventSerializer eventSerializer,
     EventDeserializer eventDeserializer)
 {
     _streamStore       = streamStore ?? throw new ArgumentNullException(nameof(streamStore));
     _eventMapping      = eventMapping ?? throw new ArgumentNullException(nameof(eventMapping));
     _eventSerializer   = eventSerializer ?? throw new ArgumentNullException(nameof(eventSerializer));
     _eventDeserializer = eventDeserializer ?? throw new ArgumentNullException(nameof(eventDeserializer));
 }
예제 #27
0
        public void SetUp()
        {
            var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
            var eventMapping      = new EventMapping(new Dictionary <string, Type>());

            _model = new Model();
            _sut   = new RepositoryScenarioBuilder(eventMapping, eventDeserializer).
                     ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1)).
                     ScheduleDeleteStream(_model.KnownIdentifier).
                     BuildForRepository();
        }
예제 #28
0
 //Return Event Defintions using Contract as an indentifier to traverse the Event mapping.
 public HashSet <EventDefinition> retrieveEventDefinitionsUsingContract(ContractDefinition contract)
 {
     if (EventMapping.ContainsKey(contract))
     {
         return(EventMapping[contract]);
     }
     else
     {
         return(new HashSet <EventDefinition>());
     }
 }
예제 #29
0
        public void SetUp()
        {
            var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
            var eventMapping      = new EventMapping(new Dictionary <string, Type>());

            _model = new Model();
            _root  = AggregateRootEntityStub.Factory();
            _sut   = new RepositoryScenarioBuilder(eventMapping, eventDeserializer).
                     ScheduleAttachToUnitOfWork(new Aggregate(_model.KnownIdentifier, 0, _root)).
                     BuildForRepository();
        }
 public StreamStoreCommandHandlerModule(
     Func <IStreamStore> getStreamStore,
     Func <ConcurrentUnitOfWork> getUnitOfWork,
     Func <ReturnHandler <CommandMessage>, T> innerModuleFactory,
     EventMapping eventMapping,
     EventSerializer eventSerializer)
 {
     _eventMapping    = eventMapping;
     _eventSerializer = eventSerializer;
     Wrap(innerModuleFactory((message, ct) => ToStreamStore(getStreamStore, getUnitOfWork, message, ct)));
 }