示例#1
0
        private async Task InsertEmptyDomainEventIfStreamIsEmpty(string streamName)
        {
            _logger.LogDebug("InsertEmptyDomainEventIfStreamIsEmpty {StreamName}", streamName);

            var empty = await _connectionProvider.IsStreamEmptyAsync(streamName).ConfigureAwait(false);

            if (empty)
            {
                _logger.LogDebug("Stream is Empty {StreamName}", streamName);

                var events = new[] { DomainEventExtensions.ToEventData(new EmptyDomainEvent(), null) };

                var name = streamName; // $"{aggregateName}-empty";

                //wenn es eine category stream ist, dann den basis stream finden und eine neue gruppe -empty erzeugen
                if (streamName.Contains("$ce-"))
                {
                    name = $"{streamName.Replace("$ce-", string.Empty)}-empty";
                }

                _logger.LogDebug("InsertEmptyEvent: StreamName {StreamName}", name);
                //var con = await _connectionProvider.GetActiveConnection().ConfigureAwait(false);
                var con = _connectionProvider.GetActiveConnection();
                await con.AppendToStreamAsync(name, -1, events, _connectionProvider.OpsCredentials).ConfigureAwait(false);
            }
            else
            {
                _logger.LogDebug("Stream is not Empty {StreamName}", streamName);
            }
        }
示例#2
0
        public void ImportEvent(ImportEvent command)
        {
            try
            {
                var succesEvent = new EventImported();

                var bridgeEvent = Mapper.Map <Event>(command);

                var pairsDictionary = new Dictionary <int, Pair>();
                command.Pairs.Each(pairMetadata =>
                {
                    var pair = Mapper.Map <Pair>(pairMetadata);
                    pairsDictionary.Add(pairMetadata.PairId, pair);
                    bridgeEvent.Pairs.Add(pair);
                });

                command.Deals.Each(dealMetadata =>
                {
                    var deal = Mapper.Map <Deal>(dealMetadata);
                    dealMetadata.DealResults.Each(duplicateDealMetadata =>
                    {
                        var duplicateDeal    = Mapper.Map <DuplicateDeal>(duplicateDealMetadata);
                        duplicateDeal.EWPair = pairsDictionary[duplicateDealMetadata.EWPairIndex];
                        duplicateDeal.NSPair = pairsDictionary[duplicateDealMetadata.NSPairIndex];
                        deal.DuplicateDeals.Add(duplicateDeal);
                    });

                    bridgeEvent.Deals.Add(deal);
                });
                bridgeEvent.IsImported = true;

                _context.Events.Add(bridgeEvent);
                _context.SaveChanges();

                DomainEventExtensions.PrepareSuccessfulEvent(succesEvent, command);
                succesEvent.EventId = bridgeEvent.Id;
                succesEvent.DealIds = bridgeEvent.Deals.Select(c => c.Id).ToArray();
                succesEvent.PairIds = bridgeEvent.Pairs.Select(c => c.Id).ToArray();
                DomainEvents.Add(succesEvent);
            }
            catch (Exception ex)
            {
                var errorEvent = Mapper.Map <ImportEventAttempted>(command);
                DomainEventExtensions.PrepareAttemptedEvent(errorEvent, ex, command);
                DomainEvents.Add(errorEvent);
            }
        }