public static ServerDomainMessage ToDomainMessage(this IMessage message, bool query = false)
{
var type = message.GetType();
var msg = new ServerDomainMessage
{
EventData = JsonConvert.SerializeObject(message.Clear()),
TypeName = type.AssemblyQualifiedName,
EventName = query ? type.FullName : type.Name,
EventType = EventType.Command,
SequenceNumber = DateTime.UtcNow.Ticks + Random.Next()
};
switch (message)
{
case IEvent @event:
msg.Id = @event.Id;
msg.Version = @event.Version;
msg.TimeStamp = @event.TimeStamp;
msg.EventType = EventType.Event;
break;
case IAmbientCommand _:
msg.EventType = EventType.AmbientCommand;
break;
}
return(msg);
}
private async void ProcessMessage(ServerDomainMessage domainMessage)
{
try
{
switch (domainMessage.EventType)
{
case EventType.AmbientCommand:
case EventType.QueryResult:
case EventType.Event:
{
if (_eventRegistrations.TryGetValue(domainMessage.EventName, out var reg))
{
_messageDeliveries.Enqueue(new MessageDelivery(reg, domainMessage));
}
break;
}
default:
_memoryCache.Set(domainMessage.SequenceNumber, domainMessage);
await _hubConnection.SendAsync(HubEventNames.TryAccept, domainMessage.SequenceNumber, _config.Value.ServiceName, _config.Value.ApiKey);
break;
}
}
catch (Exception e)
{
_logger.LogError(e, "Error on Recieving Message");
}
}
public async Task PublishEventToClient(string client, ServerDomainMessage message, string apiKey)
{
var vaildate = await _keyStore.Validate(apiKey);
if (!vaildate.Ok)
{
throw new HubException("Api Key Validation Failed");
}
await Clients.Client(client).SendAsync(HubEventNames.PropagateEvent, message);
}
public async Task Process(ServerDomainMessage msg)
{
try
{
await _msg.Invoke((IMessage)JsonConvert.DeserializeObject(msg.EventData, Type.GetType(msg.TypeName)), msg, CancellationToken.None);
}
catch (Exception e)
{
_logger.LogError(e, $"Error while Deligate to Messeage Handler {msg.EventName} {msg.EventType}");
}
}
public async Task PublishEvent(ServerDomainMessage message, string apiKey)
{
var vaildate = await _keyStore.Validate(apiKey);
if (!vaildate.Ok)
{
throw new HubException("Api Key Validation Failed");
}
_logger.LogInformation($"Event Publised: {vaildate.ServiceName} -- {message.EventName}");
await _eventManager.ProvideEvent(Context.ConnectionId, message, apiKey);
}
public override async Task Invoke(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token)
{
var obj = _target();
var spec = (obj as ISpecificationProviderBase)?.GetSpecification();
string error = null;
if (spec != null && !spec.IsSatisfiedBy(msg))
{
error = spec.Message;
}
await(Task) GetMethod()(obj, msg, error);
}
public async Task Handle(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token)
{
if (rawMessage.EventType == EventType.QueryResult)
{
using var scope = _serviceScopeFactory.CreateScope();
var handler = (GlobalEventHandlerBase)scope.ServiceProvider.GetRequiredService(typeof(GlobalEventHandler <>).MakeGenericType(msg.GetType()));
await handler.Handle(msg);
}
else
{
foreach (var handlerInstace in _handlers)
{
await handlerInstace.Handle(msg, rawMessage, token);
}
}
}
public async Task ResolveQuery(QueryRoleClaims query, ServerDomainMessage serverDomainMessage)
{
_logger.LogInformation(EventIds.UserManager.RoleManagment, $"Query Role {query.RoleId} Claims");
var role = await _userDatabase.UserRoles
.Include(e => e.Claims)
.AsNoTracking()
.FirstOrDefaultAsync(e => e.Id == query.RoleId);
var result = new UserClaims(role?.Id ?? Guid.Empty);
if (role != null)
{
result.Claims.AddRange(role.Claims.Select(e => new UserClaim(e.Data, e.Id)));
}
else
{
_logger.LogWarning(EventIds.UserManager.RoleManagment, $"Claims For {query.RoleId} Not Found: Returning Empty List");
}
await _client.RespondToQuery(result, serverDomainMessage);
}
public abstract Task Invoke(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token);
public override async Task Invoke(IMessage msg, ServerDomainMessage rawMessage, CancellationToken token) => await(Task) GetMethod()(_handler(), msg, token);
public Task SendToClient(string client, ServerDomainMessage serverDomainMessage, CancellationToken token)
{
_sendToClient?.Invoke(client, serverDomainMessage, token);
return(Task.CompletedTask);
}
public static TType ToRealMessage <TType>(this ServerDomainMessage message)
where TType : class
=> JsonConvert.DeserializeObject(message.EventData, Type.GetType(message.TypeName)) as TType;
public static async Task RespondToQuery <TType>(this IDispatcherClient client, TType result, ServerDomainMessage original)
{
if (result == null)
{
return;
}
var data = new QueryEvent <TType>(original.EventName, result);
await client.SendToClient(original.Sender, new ServerDomainMessage
{
EventName = data.GetType().FullName,
EventType = EventType.QueryResult,
EventData = JsonConvert.SerializeObject(data),
TypeName = typeof(QueryEvent <TType>).AssemblyQualifiedName
}, CancellationToken.None);
}
public RecivedDomainEvent(ServerDomainMessage realMessage, string apiKey)
{
RealMessage = realMessage;
ApiKey = apiKey;
}
public MessageDelivery(EventRegistration eventRegistration, ServerDomainMessage message)
{
_eventRegistration = eventRegistration;
_message = message;
}
public async Task SendToClient(string client, ServerDomainMessage serverDomainMessage, CancellationToken token) => await _hubConnection.SendAsync(HubEventNames.PublishEventToClient, client, serverDomainMessage, _config.Value.ApiKey, token);
