public BuyTicketCommandHandler(IIntegrationEventRepository <TicketBoughtEvent> eventRepository,
ILogger <BuyTicketCommandHandler> logger, ICounter <IProcessedCommands> processedCommandsCounter)
{
_eventRepository = eventRepository;
_logger = logger;
_processedCommandsCounter = processedCommandsCounter;
}
public IntegrationEventManager(
IIntegrationEventRepository integrationEventRepository,
IWebhookPublisher webhookPublisher)
{
_integrationEventRepository = integrationEventRepository;
_webhookPublisher = webhookPublisher;
}
/// <summary>
/// IntegrationEventsController constructor
/// </summary>
/// <param name="repository"></param>
/// <param name="membershipManager"></param>
/// <param name="userManager"></param>
/// <param name="configuration"></param>
/// <param name="httpContextAccessor"></param>
public IntegrationEventsController(
IIntegrationEventRepository repository,
IMembershipManager membershipManager,
ApplicationIdentityUserManager userManager,
IConfiguration configuration,
IHttpContextAccessor httpContextAccessor) : base(repository, userManager, httpContextAccessor, membershipManager, configuration)
{
_repository = repository;
}
private static async Task PublishUnprocessedEventsPeriodicallyAsync <T>(ILogger logger, TimeSpan period,
IIntegrationEventRepository <T> eventRepository, IMessageBroker messageBroker) where T : class, IIntegrationEvent
{
while (true)
{
await Task.Delay(period);
await PublishUnprocessedEventsAsync(logger, eventRepository, messageBroker);
}
}
public WebhookPublisher(
IIntegrationEventRepository eventRepository,
IIntegrationEventLogRepository eventLogRepository,
IIntegrationEventSubscriptionRepository eventSubscriptionRepository,
IIntegrationEventSubscriptionAttemptRepository integrationEventSubscriptionAttemptRepository,
IBackgroundJobClient backgroundJobClient,
IQueueItemRepository queueItemRepository,
IHubContext <NotificationHub> hub)
{
_eventRepository = eventRepository;
_eventLogRepository = eventLogRepository;
_eventSubscriptionRepository = eventSubscriptionRepository;
_backgroundJobClient = backgroundJobClient;
_queueItemRepository = queueItemRepository;
_attemptRepository = integrationEventSubscriptionAttemptRepository;
_hub = hub;
}
private static async Task PublishUnprocessedEventsAsync <T>(ILogger logger,
IIntegrationEventRepository <T> eventRepository, IMessageBroker messageBroker) where T : class, IIntegrationEvent
{
logger.LogDebug($"Periodic fetch of messages for type: {typeof(T).FullName}");
foreach (var @event in await eventRepository.GetAllAsync())
{
var eventId = $"{@event}:{@event.Id}";
try
{
logger.LogDebug($"Trying to publish: {eventId}");
await messageBroker.PublishAsync(@event);
logger.LogDebug($"Event published: {eventId}");
await eventRepository.RemoveAsync(@event);
logger.LogDebug($"Removed from store: {eventId}");
}
catch (Exception exception)
{
logger.LogError($"Failed to publish: {eventId}. Details: {exception.Message}");
}
}
}
