protected BaseCommandHandler(Type type, Guid token, object handler, RoutingFilter filter)
{
MessageType = type.GetTypeInfo();
Token = token;
Handler = handler;
SubscriptionFilter = filter;
}
public async Task <Event> PublishEvent(ActorMessage source, ActorMessage destination,
IMessageBroker messageBroker, RoutingFilter routingFilter)
{
if (destination.Type == "TestEvent")
{
var @event = new TestEvent();
@event.SetProperties(source);
@event.SetProperties(destination);
await messageBroker.Publish(@event, routingFilter);
return(@event);
}
if (destination.Type == "TestEvent2")
{
var @event = new TestEvent2();
@event.SetProperties(source);
@event.SetProperties(destination);
await messageBroker.Publish(@event, routingFilter);
return(@event);
}
var ev = new Event();
ev.SetProperties(source);
ev.SetProperties(destination);
await messageBroker.Publish(ev, routingFilter);
return(ev);
}
public static void RegisterHandlers(this IEventAggregator eventAggregator, Container container)
{
foreach (var type in container.GetCurrentRegistrations().Where(x => x.ServiceType.GetInterfaces().Any(y => y.IsGenericType && y.GetGenericTypeDefinition() == typeof(IHandler <>))))
{
foreach (var handlerInterface in type.ServiceType.GetInterfaces()
.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IHandler <>) && x.GenericTypeArguments.Length == 1))
{
var messageType = handlerInterface.GenericTypeArguments.FirstOrDefault();
var methodInfo = handlerInterface.GetMethods().FirstOrDefault();
var delegateType = Expression.GetActionType(methodInfo.GetParameters().Select(p => p.ParameterType).ToArray());
var interfaceMap = type.ServiceType.GetInterfaceMap(handlerInterface);
var messageFilterAttribute = interfaceMap.TargetMethods.FirstOrDefault()?.GetCustomAttributes(false)?.Where(at => at is RoutingFilterAttribute).Cast <RoutingFilterAttribute>().FirstOrDefault();
RoutingFilter messageFilter = null;
if (messageFilterAttribute != null)
{
messageFilter = messageFilterAttribute.ToMessageFilter();
}
if (type.Lifestyle == Lifestyle.Singleton)
{
eventAggregator.Subscribe(messageType, Delegate.CreateDelegate(delegateType, container.GetInstance(type.ServiceType), methodInfo.Name), messageFilter);
}
else
{
eventAggregator.Subscribe(messageType, () => Delegate.CreateDelegate(delegateType, container.GetInstance(type.ServiceType), methodInfo.Name), messageFilter);
}
}
}
}
public Task <R> QueryService <T, R>(T query, RoutingFilter filter = null) where T : Query
{
query = FormatMessage(query);
return(_eventAggregator.QueryAsync <T, R>(query, filter));
}
public IObservable <IMessageEnvelope <T> > Observe <T>(RoutingFilter routingFilter = null) where T : Event
{
if (typeof(T) == typeof(MotionEvent))
{
return((IObservable <IMessageEnvelope <T> >)_motionData);
}
throw new NotImplementedException();
}
public SubscriptionToken SubscribeForMessage <T>(PID subscriber, RoutingFilter filter = null) where T : ActorMessage
{
var sub = GetSubscription <T>(subscriber);
if (!_subscriptionCahce.Add(sub))
{
return(SubscriptionToken.Empty);
}
return(_eventAggregator.Subscribe <T>(message => _actorFactory.Context.Send(subscriber, message.Message), filter));
}
public SubscriptionToken SubscribeForQuery <T, R>(PID subscriber, RoutingFilter filter = null) where T : Query
{
var sub = GetSubscription <T>(subscriber);
if (!_subscriptionCahce.Add(sub))
{
return(SubscriptionToken.Empty);
}
return(_eventAggregator.SubscribeForAsyncResult <T>(async message => await _actorFactory.Context.RequestAsync <R>(subscriber, message.Message).ConfigureAwait(false), filter));
}
public async Task <R> QueryJsonService <T, R>(T query, RoutingFilter filter = null) where T : Query
{
query = FormatMessage(query);
var json = await _eventAggregator.QueryAsync <T, string>(query, filter);
var result = JsonConvert.DeserializeObject <R>(json);
return(result);
}
public bool IsFilterMatch(object message, RoutingFilter messageFilter)
{
if (SubscriptionFilter == null)
{
if (messageFilter == null || messageFilter?.RoutingKey == "*")
{
return(true);
}
return(false);
}
return(SubscriptionFilter?.EvaluateFilter(message, messageFilter) ?? true);
}
public static Task <R> QueryWitTimeoutAsync <T, R>
(
this IEventAggregator eventAggregate,
T message,
TimeSpan?timeout,
RoutingFilter filter = null,
CancellationToken cancellationToken = default
) where R : class
{
var chain = new BehaviorChain().WithTimeout(timeout);
return(eventAggregate.QueryAsync <T, R>(message, filter, cancellationToken, chain));
}
public static Task <R> QueryAsync <T, R>
(
this IEventAggregator eventAggregate,
T message,
RoutingFilter filter = null,
CancellationToken cancellationToken = default,
TimeSpan?timeout = null,
int retryCount = 0,
bool async = false
) where R : class
{
var chain = new BehaviorChain().WithTimeout(timeout).WithRetry(retryCount).WithAsync(async);
return(eventAggregate.QueryAsync <T, R>(message, filter, cancellationToken, chain));
}
public Task <R> QueryService <T, R>(T query, RoutingFilter filter = null)
where T : Query
{
if (query is SunriseQuery)
{
return(Task.FromResult((TimeSpan?)new TimeSpan(6, 0, 0)) as Task <R>);
}
else if (query is SunsetQuery)
{
return(Task.FromResult((TimeSpan?)new TimeSpan(18, 0, 0)) as Task <R>);
}
else
{
throw new NotImplementedException();
}
}
public Task <R> QueryJsonService <T, R>(T query, RoutingFilter filter = null)
where T : Query
{
throw new NotImplementedException();
}
public Task <Event> PublishWithTranslate(ActorMessage source, ActorMessage destination, RoutingFilter filter = null)
{
throw new NotImplementedException();
}
public Task Publish <T>(T message, RoutingFilter routingFilter = null) where T : ActorMessage
{
throw new NotImplementedException();
}
public async static Task <IEnumerable <T> > WaitForEvents <T>(this IMessageBroker broker, Action messageGenerator = null, RoutingFilter routingFilter = null, int timeout = 500) where T : Event
{
var list = new List <T>();
broker.Observe <T>(routingFilter).Subscribe((x) =>
{
list.Add(x.Message);
});
messageGenerator();
await Task.Delay(timeout);
return(list);
}
public SubscriptionToken SubscribeForQuery <T, R>(PID subscriber, bool subscribeOnParent, RoutingFilter filter = null) where T : Query
{
throw new NotImplementedException();
}
public SubscriptionToken SubscribeForMessage <T>(PID subscriber, bool subscribeOnParent, RoutingFilter filter = null) where T : ActorMessage
{
return(SubscriptionToken.Empty);
}
public SubscriptionToken SubscribeForEvent <T>(Func <IMessageEnvelope <T>, Task> action, RoutingFilter filter = null) where T : Event
{
throw new NotImplementedException();
}
protected void Subscribe <T>(RoutingFilter filter = null) where T : ActorMessage
{
_disposables.Add(MessageBroker.SubscribeForMessage <T>(Self, filter));
}
public async Task <bool> QueryServiceWithVerify <T, Q, R>(T query, R expectedResult, RoutingFilter filter = null) where T : Query, IMessageResult <Q, R>
where Q : class
{
var result = await QueryService <T, Q>(query, filter);
return(query.Verify(result, expectedResult));
}
public SubscriptionToken SubscribeForEvent <T>(Action <IMessageEnvelope <T> > action, RoutingFilter filter = null) where T : Event
{
return(_eventAggregator.Subscribe(action, filter));
}
public Task <Event> PublishWithTranslate(ActorMessage source, ActorMessage destination, RoutingFilter filter = null)
{
return(_messageGenerator.PublishEvent(source, destination, this, filter));
}
public IObservable <IMessageEnvelope <T> > Observe <T>(RoutingFilter routingFilter = null) where T : Event
{
return(_eventAggregator.Observe <T>(routingFilter));
}
public Task Publish <T>(T message, RoutingFilter routingFilter = null) where T : ActorMessage
{
return(_eventAggregator.Publish(message, routingFilter));
}
public Task SendToService <T>(T command, RoutingFilter filter = null) where T : Command
{
command = FormatMessage(command);
return(_eventAggregator.Publish(command, filter));
}
public Task <bool> QueryServiceWithVerify <T, Q, R>(T query, R expectedResult, RoutingFilter filter = null)
where T : Query, IMessageResult <Q, R>
where Q : class
{
throw new NotImplementedException();
}
public CommandHandler(Type type, Guid token, object handler, RoutingFilter filter) : base(type, token, handler, filter)
{
}
protected void Subscribe <T, R>(RoutingFilter filter = null) where T : Query
{
_disposables.Add(MessageBroker.SubscribeForQuery <T, R>(Self, filter));
}
public Task SendToService <T>(T command, RoutingFilter filter = null) where T : Command
{
throw new NotImplementedException();
}
