Beispiel #1
0
 private async Task SaveEventAndOrderingContextChangesAsync(IntegrationEvent evt)
 {
     await ResilientTransaction.New(_productContext)
     .ExecuteAsync(async() => {
         await _productContext.SaveChangesAsync();
         await _integrationEventLogService.SaveEventAsync(evt, _productContext.Database.CurrentTransaction.GetDbTransaction());
     });
 }
 public async Task SaveEventAndCatalogContextChangesAsync(IntegrationEvent evt)
 {
     await ResilientTransaction.New(_catalogContext).ExecuteAsync(async() =>
     {
         await _catalogContext.SaveChangesAsync();
         await _eventLogService.SaveEventAsync(evt, _catalogContext.Database.CurrentTransaction);
     });
 }
        public async Task AddAndSaveEventAsync(IntegrationEvent integrationEvent)
        {
            _logger.LogInformation(
                "----- Enqueuing integration event {IntegrationEventId} to repository ({@IntegrationEvent})",
                integrationEvent.Id, integrationEvent);

            await _eventLogService.SaveEventAsync(integrationEvent, _deliveryContext.GetCurrentTransaction());
        }
Beispiel #4
0
        public Task PublishThroughEventBusAsync(IEvent evt)
        {
            Task[] tasks = new Task[3];
            tasks[0] = _eventLogService.SaveEventAsync(evt, _context.Database.CurrentTransaction.GetDbTransaction());
            tasks[1] = _eventBus.Publish(evt);
            tasks[2] = _eventLogService.MarkEventAsPublishedAsync(evt);

            return(Task.WhenAll(tasks));
        }
Beispiel #5
0
 public async Task SaveEventAndCatalogContextChangesAsync(IntegrationEvent @event)
 {
     await ResilientTransaction.New(_catalogContext).ExecuteAsync(async() =>
     {
         _logger.Information($"SaveEventAndCatalogContextChangesAsync  {@event}");
         await _catalogContext.SaveChangesAsync();
         await _eventLogService.SaveEventAsync(@event, _catalogContext.Database.CurrentTransaction);
     });
 }
Beispiel #6
0
 public async Task SaveEventAndInventoryContextChangesAsync(IntegrationEvent evt)
 {
     await ResilientTransaction.New(_inventoryContext)
     .ExecuteAsync(async() =>
     {
         await _inventoryContext.SaveChangesAsync();
         await _eventLogService.SaveEventAsync(evt, DbContextTransactionExtensions.GetDbTransaction(_inventoryContext.Database.CurrentTransaction));
     });
 }
Beispiel #7
0
        public async Task AddAndSaveEventAsync(IntegrationEvent evt)
        {
            logger.LogInformation("----- Enqueuing integration event {IntegrationEventId} to repository ({@IntegrationEvent})", evt.Id, evt);

            await eventLogService.SaveEventAsync(
                evt,
                dbContext.CurrentTransactionId
                );
        }
Beispiel #8
0
        public async Task <ActionResult> UpdateProductAsync([FromBody] CatalogItem productToUpdate)
        {
            var catalogItem = await _catalogContext.CatalogItems.SingleOrDefaultAsync(i => i.Id == productToUpdate.Id);

            if (catalogItem == null)
            {
                return(NotFound(new { Message = $"Item with id {productToUpdate.Id} not found." }));
            }

            var oldPrice = catalogItem.Price;
            var raiseProductPriceChangedEvent = oldPrice != productToUpdate.Price;

            // Update current product
            catalogItem = productToUpdate;
            _catalogContext.CatalogItems.Update(catalogItem);

            if (raiseProductPriceChangedEvent) // Save product's data and publish integration event through the Event Bus if price has changed
            {
                _logger.LogInformation(" [x] CatalogController.UpdateProduct(): Price has changed, integration event is being prepared...");

                var productPriceChangeEvent = new ProductPriceChangedIntegrationEvent(productToUpdate.Id,
                                                                                      oldPrice, productToUpdate.Price);

                var strategy = _catalogContext.Database.CreateExecutionStrategy();
                _logger.LogInformation(" [x] CatalogController.UpdateProductAsync(): Beginning new transaction to save event and commit changes.");
                await strategy.Execute(async() => {
                    using (var transaction = _catalogContext.Database.BeginTransaction())
                    {
                        await _eventLogService.SaveEventAsync(productPriceChangeEvent, transaction);
                        await _catalogContext.SaveChangesAsync();
                        transaction.Commit();
                        _logger.LogInformation(" [x] CatalogController.UpdateProductAsync(): Transaction ({0}) has been committed.", transaction.TransactionId);
                    }
                });

                try
                {
                    await _eventLogService.MarkEventAsInProgressAsync(productPriceChangeEvent.Id);

                    _eventBus.Publish(productPriceChangeEvent);
                    await _eventLogService.MarkEventAsPublishedAsync(productPriceChangeEvent.Id);
                }

                catch (Exception e)
                {
                    _logger.LogError(e, " [x] CatalogController.UpdateProductAsync(): Fail when publishing integration event {0}.", productPriceChangeEvent.Id);
                    await _eventLogService.MarkEventAsFailedAsync(productPriceChangeEvent.Id);
                }
            }
            else // Just save the updated product because the Product's Price hasn't changed.
            {
                await _catalogContext.SaveChangesAsync();
            }

            return(Ok());
        }
Beispiel #9
0
        public async Task SaveEventAndCatalogContextChangesAsync(IntegrationEvent evt)
        {
            _logger.LogInformation("----- CatalogIntegrationEventService - Saving changes and integrationEvent: {IntegrationEventId}", evt.Id);

            await ResilientTransaction.New(_gestaoNormasDbContext).ExecuteAsync(async() =>
            {
                await _gestaoNormasDbContext.SaveChangesAsync();
                await _eventLogService.SaveEventAsync(evt, _gestaoNormasDbContext.Database.CurrentTransaction);
            });
        }
        public async Task AddAndSaveEventAsync(IntegrationEvent evt)
        {
            _logger.LogInformation("----- IdentityIntegrationEventService - Saving changes and integrationEvent: {IntegrationEventId}", evt.Id);

            await ResilientTransaction.New((DbContext)_customIdentityDbContext).ExecuteAsync(async() =>
            {
                // Achieving atomicity between original database operation and the IntegrationEventLog thanks to a local transaction
                await _customIdentityDbContext.SaveChangesAsync();
                await _eventLogService.SaveEventAsync(evt, _customIdentityDbContext.Database.CurrentTransaction);
            });
        }
Beispiel #11
0
 private async Task SaveEventAndBusinessDbContextChangesAsync(IEvent evt)
 {
     //Use of an EF Core resiliency strategy when using multiple DbContexts within an explicit BeginTransaction():
     //See: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
     await ResilientTransaction.New(_context)
     .ExecuteAsync(async() => {
         // Achieving atomicity between original ordering database operation and the IntegrationEventLog thanks to a local transaction
         await _context.SaveChangesAsync();
         await _eventLogService.SaveEventAsync(evt, _context.Database.CurrentTransaction.GetDbTransaction());
     });
 }
        public async Task SaveEventAndCatalogContextChangesAsync(IntegrationEvent evt)
        {
            _logger.LogInformation("----- CatalogIntegrationEventService - Saving changes and integrationEvent: {IntegrationEventId}", evt.Id);

            //Use of an EF Core resiliency strategy when using multiple DbContexts within an explicit BeginTransaction():
            //See: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
            await ResilientTransaction.New(_catalogContext).ExecuteAsync(async() => {
                // Achieving atomicity between original catalog database operation and the IntegrationEventLog thanks to a local transaction
                await _catalogContext.SaveChangesAsync();
                await _eventLogService.SaveEventAsync(evt, _catalogContext.Database.CurrentTransaction.GetDbTransaction());
            });
        }
Beispiel #13
0
 public async Task SaveEventAndMovieContextChangesAsync(Microsoft.eShopOnContainers.BuildingBlocks.EventBus.Events.IntegrationEvent evt)
 {
     //Use of an EF Core resiliency strategy when using multiple DbContexts within an explicit BeginTransaction():
     //See: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
     await ResilientTransaction.New(_movieContext)
     .ExecuteAsync(async() =>
     {
         // Achieving atomicity between original catalog database operation and the IntegrationEventLog thanks to a local transaction
         await _movieContext.SaveChangesAsync();
         await _eventLogService.SaveEventAsync(evt, _movieContext.Database.CurrentTransaction.GetDbTransaction());
     });
 }
        public async Task DeleteEventAndOperacaoContextChangesAsync(IntegrationEvent evt)
        {
            var strategy = _moduloContext.Database.CreateExecutionStrategy();
            await strategy.ExecuteAsync(async() => {
                using (var transaction = _moduloContext.Database.BeginTransaction())

                {
                    try
                    {
                        await _moduloContext.SaveChangesAsync();
                        await _eventLogService.SaveEventAsync(evt, _moduloContext.Database.CurrentTransaction.GetDbTransaction());
                        transaction.Commit();
                    }
                    catch (Exception ex)
                    {
                        transaction.Rollback();
                        var sqlException = ex.InnerException as System.Data.SqlClient.SqlException;
                        throw new Exception(sqlException.Number + "::" + sqlException.Message);
                    }
                }
            });
        }
Beispiel #15
0
        public async Task SaveEventAndChangesAsync(IntegrationEvent evt)
        {
            _logger.LogInformation("----- POSIntegrationEventService - Saving changes and integrationEvent: {IntegrationEventId}", evt.Id);
            await ResilientTransaction.New(_posContext, _logger).ExecuteAsync(async() =>
            {
                // Achieving atomicity between original catalog database operation and the IntegrationEventLog thanks to a local transaction
                try
                {
                    if (await _posContext.SaveChangesAsync() <= 0)
                    {
                        _logger.LogError("----- POSIntegrationEventService {0}", "Not can saved in Db");
                    }
                }
                catch (DbUpdateException e)
                {
                    _logger.LogError("***** Error In SaveChangesAsync Process {0}", e.Message);
                }

                await _eventLogService.SaveEventAsync(@event: evt, transaction: Guid.NewGuid());
            });
        }
Beispiel #16
0
 public async Task SaveEventAsync(IntegrationEvent evt)
 {
     _logger.LogInformation("Saving integrationEvent: {IntegrationEventId}", evt.Id);
     await _eventLogService.SaveEventAsync(evt);
 }
        public async Task <ActionResult> UpdateAsync([FromBody] RoomDTO roomDTO)
        {
            if (roomDTO == null)
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "Room data is null"
                }));
            }

            if (string.IsNullOrWhiteSpace(roomDTO.Name))
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "Room name is empty"
                }));
            }

            var room = await roomRepository.GetByIdAsync(roomDTO.Id);

            if (room == null)
            {
                // return new BadRequestObjectResult(new ErrorDTO { ErrorMessage = "Room does not exist" });
                return(NotFound(new ErrorDTO {
                    ErrorMessage = "Room does not exist"
                }));
            }


            bool roomWithNameExists = roomRepository.GetAll().Any(r => r.Id != roomDTO.Id && r.Name == roomDTO.Name);

            if (roomWithNameExists)
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "Room with passed name does exist"
                }));
            }

            bool isRoomNameChanged = false, isRoomManagerChanged = false, isSlicesPerPizzaChanged = false;
            RoomNameChangedEvent             roomNameChangedEvent = null;
            RoomManagerChangedEvent          roomManagerChangedEvent = null;
            SlicesPerPizzaInRoomChangedEvent slicesPerPizzaInRoomChangedEvent = null;


            if (room.Name != roomDTO.Name)
            {
                isRoomNameChanged = true;

                room.Name = roomDTO.Name;

                roomNameChangedEvent = new RoomNameChangedEvent(room.Id, room.Name);
            }

            if (room.ManagerId != roomDTO.ManagerId)
            {
                isRoomManagerChanged = true;

                room.ManagerId   = roomDTO.ManagerId;
                room.ManagerName = roomDTO.ManagerName;

                roomManagerChangedEvent = new RoomManagerChangedEvent(room.Id, room.Name, room.ManagerId, room.ManagerName);
            }

            if (room.SlicesPerPizza != roomDTO.SlicesPerPizza)
            {
                isSlicesPerPizzaChanged = true;

                room.SlicesPerPizza = roomDTO.SlicesPerPizza;

                slicesPerPizzaInRoomChangedEvent = new SlicesPerPizzaInRoomChangedEvent(room.Id, room.Name, room.SlicesPerPizza);
            }

            if (isRoomNameChanged || isRoomManagerChanged || isSlicesPerPizzaChanged)
            {
                // Publish integration events
                using (var transaction = session.BeginTransaction())
                {
                    await roomRepository.UpdateAsync(room.Id, room);

                    if (isRoomNameChanged)
                    {
                        await integrationEventLogService.SaveEventAsync(roomNameChangedEvent);
                    }
                    if (isRoomManagerChanged)
                    {
                        await integrationEventLogService.SaveEventAsync(roomManagerChangedEvent);
                    }
                    if (isSlicesPerPizzaChanged)
                    {
                        await integrationEventLogService.SaveEventAsync(slicesPerPizzaInRoomChangedEvent);
                    }
                    transaction?.Commit();
                }
            }

            return(NoContent());
        }
        public async Task SaveEventAsync(IntegrationEvent evt, System.Guid guid)
        {
            _logger.LogInformation("----- BotIntegrationEventService - Saving changes and integrationEvent: {IntegrationEventId}", evt.Id);

            await _eventLogService.SaveEventAsync(evt, guid);
        }
 public async Task AddAndSaveEventAsync(IntegrationEvent evt)
 {
     var trans = _context.Database.CurrentTransaction.GetDbTransaction();
     await _eventLogService.SaveEventAsync(evt, trans);
 }
 public async Task AddEventsAsync(IntegrationEvent integrationEvent)
 {
     await _integrationEventLogService.SaveEventAsync(integrationEvent, _smarthubContext.Database.CurrentTransaction);
 }
Beispiel #21
0
        public async Task SaveEventAsync(IntegrationEvent evt)
        {
            _logger.LogInformation("Saving integrationEvent: {IntegrationEventId}", evt.Id);

            await _eventLogService.SaveEventAsync(evt /*, _zeusContext.Database.CurrentTransaction*/);
        }
        public async Task <IActionResult> RegisterAsync([FromBody] RegisterUserDTO registerUserDTO)
        {
            if (registerUserDTO == null)
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "Register data is null"
                }));
            }

            if (string.IsNullOrWhiteSpace(registerUserDTO.Email) ||
                string.IsNullOrWhiteSpace(registerUserDTO.Password) ||
                string.IsNullOrWhiteSpace(registerUserDTO.Password2))
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "Email or password is empty"
                }));
            }

            if (registerUserDTO.Password.Length < 7)
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "Password is too short"
                }));
            }

            if (registerUserDTO.Password != registerUserDTO.Password2)
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "Passwords are not equal"
                }));
            }

            var user = await userRepository.GetByEmailAsync(registerUserDTO.Email);

            if (user != null)
            {
                return(new BadRequestObjectResult(new ErrorDTO {
                    ErrorMessage = "User does exist"
                }));
            }

            var passwordHash = passwordHasher.Hash(registerUserDTO.Email, registerUserDTO.Password);

            user = new User {
                Email = registerUserDTO.Email, PasswordHash = passwordHash
            };

            using (var transaction = dbContext.Database.BeginTransaction())
            {
                await userRepository.CreateAsync(user);

                await dbContext.SaveChangesAsync();

                var userRegisteredEvent = new UserRegisteredEvent(user.Id, user.Email);

                await integrationEventLogService.SaveEventAsync(userRegisteredEvent);

                await dbContext.SaveChangesAsync();

                transaction.Commit();
            }

            return(NoContent());
        }
 public async Task AddAndSaveEventAsync(IntegrationEvent integrationEvent)
 {
     // TODO: SF: Pass the DbTransaction from IUnitOfWork ala OrderingContext
     await _eventLogService.SaveEventAsync(integrationEvent, null);
 }
Beispiel #24
0
 public async Task AddAndSaveEventAsync(IntegrationEvent evt)
 {
     await eventLogService.SaveEventAsync(evt);
 }
Beispiel #25
0
        public async Task SaveEventAndCatalogContextChangesAsync(IntegrationEvent evt)
        {
            await _catalogContext.SaveChangesAsync();

            await _integrationEventLogService.SaveEventAsync(evt);
        }
 public async Task AddAndSaveEventAsync(IntegrationEvent evt)
 {
     await _eventLogService.SaveEventAsync(evt, _attachmentContext.GetCurrentTransaction.GetDbTransaction());
 }
 public async Task AddAndSaveEventAsync <T>(T evt) where T : IntegrationEvent
 {
     await _eventLogService.SaveEventAsync(evt);
 }
Beispiel #28
0
        public async Task AddAndSaveEventAsync(IntegrationEvent evt)
        {
            _logger.LogInformation("Adding integration event {IntegrationEventId} to repository ({@IntegrationEvent})", evt.Id, evt);

            await _eventLogService.SaveEventAsync(evt, _productDbContext.GetCurrentTransaction());
        }
Beispiel #29
0
        public async Task AddAndSaveEventAsync(IntegrationEvent evt)
        {
            _logger.LogInformation("----- Enqueuing integration event {IntegrationEventId} to repository ({@IntegrationEvent})", evt.Id, evt);

            await _eventLogService.SaveEventAsync(evt);
        }
 /// <summary>
 /// Persist given event to integration event log database.
 /// For details on how the persisting works and why it might fail, refer to the class summary.
 /// </summary>
 /// <param name="@event">The integration event to persist.</param>
 /// <typeparam name="TEvent">The type of the integration event.</typeparam>
 public async Task AddAndSaveEventAsync <TEvent>(TEvent @event) where TEvent : IIntegrationEvent
 {
     _logger.LogDebug("Storing event for processing. Details: {0}", @event);
     await _integrationEventLogService.SaveEventAsync(@event, _dbContext.GetCurrentTransaction());
 }