async Task ProcessEventAsync(string eventName, string eventMessage)
{
if (!subscriptionsManager.HasSubscriptions(eventName))
{
return;
}
var eventType = subscriptionsManager.GetEventType(eventName);
var @event = JsonSerializer.Deserialize(eventMessage, eventType);
var handlerMethod = typeof(IEventHandler <>).MakeGenericType(eventType).GetMethod(nameof(IEventHandler <object> .HandleAsync));
var handlerTypes = subscriptionsManager.GetEventHandlerTypes(eventName);
using var scope = serviceProvider.CreateScope();
foreach (var handlerType in handlerTypes)
{
try
{
var handler = ActivatorUtilities.GetServiceOrCreateInstance(scope.ServiceProvider, handlerType);
await(Task) handlerMethod.Invoke(handler, new[] { @event });
logger.LogDebug($"{handlerType.FullName}=>{eventMessage}");
}
catch (Exception ex)
{
logger.LogError($"{ex.Message} in {handlerType.FullName}=>{eventMessage}");
}
}
}
private async Task HandleFixedTypeIntegrationEvent(Message message)
{
// Fixed Type
// Extract the input message.body and convert to type
var eventType = _subscriptions.GetEventType(message.Label);
if (eventType == null)
{
return;
}
var data = Encoding.UTF8.GetString(message.Body);
if (string.IsNullOrWhiteSpace(data))
{
return;
}
var integrationEvent = JsonConvert.DeserializeObject(data, eventType);
if (integrationEvent is IntegrationEvent @event)
{
if (string.IsNullOrWhiteSpace(message.MessageId))
{
_logger.LogError("Missing requestId or is invalid");
return;
}
if (string.IsNullOrWhiteSpace(message.PartitionKey))
{
_logger.LogError("Missing tenantId or is invalid");
return;
}
@event.TenantId = message.PartitionKey;
@event.CorrelationId = message.CorrelationId;
@event.RequestId = message.MessageId;
}
var fixedTypeSubscribers = _subscriptions.GetSubscribers(message.Label);
foreach (var subscriber in fixedTypeSubscribers)
{
// Find handler for the message type
var handler = ActivatorUtilities.GetServiceOrCreateInstance(_services, subscriber.HandlerType);
if (handler == null)
{
continue;
}
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
// Process handler
await(Task) concreteType.GetMethod("Handle").Invoke(handler, new[] { integrationEvent });
}
}
private async Task ProcessAsync(Message message)
{
if (message == null)
{
return;
}
var data = Encoding.UTF8.GetString(message.Body);
if (string.IsNullOrWhiteSpace(data))
{
return;
}
var eventName = $"{message.Label}{IntegrationEventSuffix}";
if (!_subscriptions.HasSubscribers(eventName))
{
return;
}
using (var scope = _serviceProvider.CreateScope())
{
var subscribers = _subscriptions.GetSubscribers(eventName);
foreach (var subscriber in subscribers)
{
if (subscriber.IsDynamic)
{
if (scope.ServiceProvider.GetService(subscriber.HandlerType) is IDynamicIntegrationEventHandler handler)
{
dynamic eventData = JObject.Parse(data);
await handler.Handle(eventData).ConfigureAwait(false);
}
}
else
{
var eventType = _subscriptions.GetEventType(eventName);
var integrationEvent = JsonConvert.DeserializeObject(data, eventType);
var handler = scope.ServiceProvider.GetService(subscriber.HandlerType);
if (handler != null)
{
var concreteType = typeof(IIntegrationEventHandler <>).MakeGenericType(eventType);
await(Task) concreteType.GetMethod("Handle")
.Invoke(handler, new object[] { integrationEvent });
}
}
}
}
// Complete the message so that it is not received again.
await _subscriptionClient.CompleteAsync(message.SystemProperties.LockToken);
}
