Пример #1
0
        private void OnConfiguring(ContextBuilder builder)
        {
            var serializer = EventStoreSerializer.FromAggregateTypes(this.aggregateTypes);

            builder.EventStore = new Lazy <IEventStore>(
                () => new EventStore(this.EventStoreDb ?? new LocalEventStore(),
                                     this.EventStoreBus ?? new EventBus(builder.MessageBus.Value),
                                     serializer));
        }
Пример #2
0
        public void SetUp()
        {
            this.eventStore = new EventStore(
                new LocalEventStore(),
                new Mock <IEventStoreBus>().Object,
                EventStoreSerializer.FromAggregateTypes(typeof(Sample.Counter)));

            this.queryStore = new LocalQueryStore <CounterStats>();
        }
Пример #3
0
        private IAggregateRepository <Counter> CreateRaceRepository()
        {
            var bus = new Mock <IEventStoreBus>();

            bus.Setup(b => b.Publish(It.IsAny <IAggregateEvent <JObject> >()))
            .Returns(Task.FromResult(true));
            bus.Setup(b => b.Publish(It.IsAny <IEnumerable <IAggregateEvent <JObject> > >()))
            .Returns(Task.FromResult(true));

            var eventStore = new EventStore(
                new LocalEventStore(),
                bus.Object,
                EventStoreSerializer.FromAggregateTypes(typeof(Counter)));

            var repository = new AggregateRepository <Counter>(eventStore);

            return(repository);
        }
Пример #4
0
        private async Task SubscribeAsync(CancellationToken token)
        {
            _subscription = await _client.SubscribeAsync(
                streamName : "$ce-account",
                groupName : "account-view",
                eventAppeared : async(subscription, resolvedEvent, retryCount, token) =>
            {
                var eventRecord = resolvedEvent.Event;
                if (IsSystemEvent(eventRecord))
                {
                    return;
                }

                BackgroundServiceStatistics.SetLastProcessTime();

                var(@event, _) = EventStoreSerializer.Deserialize(eventRecord);

                switch (@event)
                {
                case AccountOpened accountOpened:
                    {
                        await UpdateViewAsync(view => view.HandleAsync(accountOpened, token));
                        break;
                    }

                case DepositedToAccount depositedToAccount:
                    {
                        var version = (int)eventRecord.EventNumber.ToUInt64();
                        await UpdateViewAsync(view => view.HandleAsync(depositedToAccount, version, token));
                        break;
                    }

                case WithdrawnFromAccount withdrawnFromAccount:
                    {
                        var version = (int)eventRecord.EventNumber.ToUInt64();
                        await UpdateViewAsync(view => view.HandleAsync(withdrawnFromAccount, version, token));
                        break;
                    }

                case AddedInterestsToAccount addedInterestsToAccount:
                    {
                        var version = (int)eventRecord.EventNumber.ToUInt64();
                        await UpdateViewAsync(view => view.HandleAsync(addedInterestsToAccount, version, token));
                        break;
                    }

                case AccountFrozen accountFrozen:
                    {
                        var version = (int)eventRecord.EventNumber.ToUInt64();
                        await UpdateViewAsync(view => view.HandleAsync(accountFrozen, version, token));
                        break;
                    }

                case AccountUnfrozen accountUnfrozen:
                    {
                        var version = (int)eventRecord.EventNumber.ToUInt64();
                        await UpdateViewAsync(view => view.HandleAsync(accountUnfrozen, version, token));
                        break;
                    }

                case AccountClosed accountClosed:
                    {
                        await UpdateViewAsync(view => view.HandleAsync(accountClosed, token));
                        break;
                    }
                }
            },
                subscriptionDropped : (subscription, reason, exception) =>
            {
                SubscribeAsync(token).Wait(token);
            },
                cancellationToken : token);
        }