Exemplo n.º 1
0
        public async Task <T> GetAsync(TKey id, CancellationToken cancellationToken)
        {
            if (Aggregates.ContainsKey(id))
            {
                var aggregate = Aggregates[id];
                if (!aggregate.IsVersionSync)
                {
                    return(aggregate);
                }

                return(await GetAsync(aggregate, cancellationToken));
            }

            var snapshoot = await SnapshootRepository.GetSnapshootAsync(id, cancellationToken);

            if (snapshoot != null)
            {
                return(await GetAsync(snapshoot, cancellationToken));
            }

            var events = await EventStore.GetAggregateEvents(AggregateType, id, cancellationToken).ToListAsync(cancellationToken);

            var instance = Activator.CreateInstance(typeof(T), new object[] { id, events }) as T;

            Aggregates[id] = instance;
            EventStore.TryAddEventContainer(instance);

            return(instance);
        }
Exemplo n.º 2
0
        public void Handle(UpdateItemCommand command)
        {
            var itemEvents = EventStore.GetAggregateEvents <ItemBaseEvent>(command.Id);
            var item       = new Item();

            item.LoadFromHistory(itemEvents);
            item.Update(command.Name, command.Quantity);

            var events = item.GetUncommittedEvents();

            EventStore.Persist(events);

            foreach (var @event in events)
            {
                EventBus.Send(@event);
            }
        }
        public void Handle(DeleteItemCommand command)
        {
            var itemEvents = EventStore.GetAggregateEvents <ItemBaseEvent>(command.Id);

            var item = new Item();

            item.LoadFromHistory(itemEvents);
            item.Delete();

            var uncommitedEvents = item.GetUncommittedEvents();

            EventStore.Persist(uncommitedEvents);

            foreach (var @event in uncommitedEvents)
            {
                EventBus.Send(@event);
            }
        }
Exemplo n.º 4
0
        public async Task <T> GetAsync(T snapshoot, CancellationToken cancellationToken)
        {
            if (!snapshoot.IsVersionSync)
            {
                throw new VersionNotAccurateException();
            }

            var snapshootVersion = snapshoot.Version;
            var lastVersion      = await EventStore.GetAggregateLastVersionAsync(AggregateType, snapshoot.Id, cancellationToken);

            if (snapshootVersion < lastVersion)
            {
                var events = await EventStore.GetAggregateEvents(AggregateType, snapshoot.Id, snapshootVersion, cancellationToken).ToListAsync(cancellationToken);

                snapshoot.UpdateFromStore(events);
            }

            Aggregates.TryAdd(snapshoot.Id, snapshoot);
            EventStore.TryAddEventContainer(snapshoot);

            return(snapshoot);
        }