public void Dispatch(BaseEvent domainEvent)
{
var handlerType = typeof(IHandler <>).MakeGenericType(domainEvent.GetType());
var wrapperType = typeof(DomainEventHandler <>).MakeGenericType(domainEvent.GetType());
var handlers = _container.GetServices(handlerType);
var wrappedHandlers = handlers
.Cast <object>()
.Select(handler => (DomainEventHandler)Activator.CreateInstance(wrapperType, handler));
foreach (var handler in wrappedHandlers)
{
handler.Handle(domainEvent);
}
}
public static EventData ToEventData(BaseEvent evnt, IDictionary<string, object> headers)
{
var data = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(evnt, SerializerSettings));
var eventHeaders = new Dictionary<string, object>(headers)
{
{
"EventClrTypeName", evnt.GetType().AssemblyQualifiedName
}
};
var metadata = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(eventHeaders, SerializerSettings));
var typeName = TypeToCamelcase(evnt.GetType());
return new EventData(evnt.EventId, typeName, true, data, metadata);
}
public void PublishEvent(BaseEvent e)
{
var factory = new ConnectionFactory()
{
HostName = "192.168.1.5", //192.168.1.5
UserName = "******",
Password = "******"
};
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
JsonSerializerSettings settings = new JsonSerializerSettings();
settings.DateFormatHandling = DateFormatHandling.IsoDateFormat;
settings.NullValueHandling = NullValueHandling.Include;
string message = JsonConvert.SerializeObject(e, settings);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Headers = new Dictionary <string, object>();
properties.Headers.Add("EventType", e.GetType().Name);
channel.BasicPublish("PostorderCompany", e.routingKey, properties, body);
}
}
}
public static EventName GetEventName(BaseEvent inevent)
{
EventName result;
var success = Enum.TryParse(inevent.GetType().Name, true, out result);
return(success ? result : EventName.Undefined);
}
public void RunCallbacks(BaseEvent ev)
{
if (!_registeredListeners.ContainsKey(ev.GetType()))
{
if (!_registeredListeners.ContainsKey(ev.GetType().BaseType))
{
return;
}
}
var registeredEvents = _registeredListeners[ev.GetType()];
foreach (var registeredEvent in registeredEvents)
{
registeredEvent.Call(ev);
}
}
static EventData GetEventData(BaseEvent evt)
{
var metaDataStr = JsonConvert.SerializeObject(evt.MetaData);
var contentStr = JsonConvert.SerializeObject(evt);
return(new EventData(Guid.NewGuid(), evt.GetType().Name, true,
Encoding.UTF8.GetBytes(contentStr), Encoding.UTF8.GetBytes(metaDataStr)));
}
// Raise the event to all the listeners
public static void Raise(BaseEvent e)
{
EventDelegate del;
if (Instance.delegates.TryGetValue(e.GetType(), out del))
{
del.Invoke(e);
}
}
/// <summary>
/// Call a event
/// </summary>
/// <param name="e">Event Type</param>
public static void Raise(BaseEvent e)
{
Init();
EventDelegate del;
_delegates.TryGetValue(e.GetType(), out del);
del?.Invoke(e);
}
public void Dispatch(BaseEvent e)
{
EventDelegate del;
if (delegates.TryGetValue(e.GetType(), out del))
{
del.Invoke(e);
}
}
/// <summary>
/// Raises an event and notifies all subscribers.
/// </summary>
/// <param name="evt">The event parameter</param>
public static void Event(BaseEvent evt)
{
EventDelegate del;
if (dispatchDelegates.TryGetValue(evt.GetType(), out del))
{
del.Invoke(evt);
}
}
/// <summary>
/// Perform actual send
/// </summary>
private void Send(IDebugProcess2 process, IDebugProgram2 program, IDebugThread2 thread, BaseEvent @event)
{
var guid = @event.IID;
DLog.Debug(DContext.VSDebuggerEvent, "DebugEngine Event {0} {1}", @event.GetType().Name, guid);
var rc = callback.Event(engine, process, program, thread, @event, ref guid, (uint)@event.Attributes);
if (!ErrorHandler.Succeeded(rc))
{
DLog.Error(DContext.VSDebuggerEvent, "DebugEngine Event failed {0}", rc);
}
}
public void LogEvent(BaseEvent anEvent)
{
var options = EntityConverter.GetJsonSerializerOptions();
options.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
options.Converters.Add(new RemoveUserInfo());
var serializedEvent = JsonSerializer.Serialize(anEvent, anEvent.GetType(), options);
_log.WithTag("Event Type", anEvent.GetEventType().ToString()).Info($"sending event: {anEvent.GetEventType()} - {serializedEvent}");
}
/// <summary>
/// General EventHandler (more like an EventHub)
/// </summary>
public void HandleEvent(BaseEvent inEvent)
{
var eventType = inEvent.GetType();
var handlerList = _handlerActions[eventType];
foreach (var action in handlerList)
{
action.Invoke(inEvent);
}
}
protected async Task WriteToStream(BaseEvent evt)
{
await _fixture.Context.DomainEvents.AddAsync(new DomainEvent()
{
CreatedOn = DateTime.UtcNow,
CreatedBy = "system",
EventType = evt.GetType().Name,
Content = JsonConvert.SerializeObject(evt)
});
await _fixture.Context.SaveChangesAsync();
}
public void TriggerEvent(string eventName, BaseEvent e)
{
if (e == null)
{
Debug.Log("Invalid event argument: " + e.GetType().ToString());
return;
}
if (delegates.ContainsKey(eventName))
{
delegates[eventName].DynamicInvoke(e);
}
}
private void processEvent(BaseEvent receivedEvent)
{
if (receivedEvent is MouseEvent)
{
processMouseEvent((MouseEvent)receivedEvent);
}
else if (receivedEvent is KeyEvent)
{
processKeyEvent((KeyEvent)receivedEvent);
}
else
{
throw new NotImplementedException($"Handle for event class '{receivedEvent.GetType()}' not implemented");
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
BaseEvent e = value as BaseEvent;
if (e == null)
{
return(Visibility.Collapsed);
}
if (e.GetType() != typeof(KillEvent) && Settings.Default.LogOnlyKillOnOverview)
{
return(Visibility.Collapsed);
}
return(Visibility.Visible);
}
private static void OnLuaEvent(BaseEvent Event)
{
if (!EventList_.ContainsKey(Event.EventName))
{
return;
}
var Properties = Event.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
var Table = LuaEnv_.NewTable();
foreach (var Property in Properties)
{
Table.SetInPath(Property.Name, Property.GetValue(Event));
}
foreach (var Evt in EventList_[Event.EventName])
{
Evt.Value.Invoke(Evt.Key, Table);
}
}
private static void FireWmiEventCore(BaseEvent baseEvent)
{
try
{
baseEvent.Fire();
}
catch (Exception exp)
{
string msg = SR.WmiEventFailure(baseEvent.GetType().Name, GetErrorMessage(exp));
COMException comException = exp as COMException;
if (null != comException)
{
if ((uint)comException.ErrorCode == WbemAccessDenied)
{
msg = string.Concat(SR.ExceptionAccessDeniedFailure, msg);
}
}
ReportWmiFailure(msg);
}
}
public IEnumerable <BaseEventHandler> GetEventHandlersOrDefault(BaseEvent eventPayload)
{
var type = eventPayload.GetType();
var handlers = new List <BaseEventHandler>();
foreach (var eventHandler in eventHandlers)
{
if (eventHandler.CanHandleEvent(type))
{
handlers.Add(eventHandler);
}
}
if (handlers.Count == 0)
{
handlers.Add(new DefaultHandler());
}
return(handlers);
}
public override async Task <string> HandleEvent(
APIGatewayProxyRequest request,
ILambdaContext context,
string deliveryId,
BaseEvent eventPayload)
{
if (eventPayload is T tPayload)
{
return(await HandleEvent(request, context, deliveryId, tPayload));
}
else
{
throw new ArgumentException(
$"EventHandler expects payload of type '{typeof(T)}', received type '{eventPayload.GetType()}'",
nameof(eventPayload));
}
}
public void LogEvent(BaseEvent anEvent)
{
var serializedEvent = JsonSerializer.Serialize(anEvent, anEvent.GetType(), _options);
_log.WithTag("Event Type", anEvent.GetEventType().ToString()).Info($"sending event: {anEvent.GetEventType()} - {serializedEvent}");
}
public static void TraceBaseEvent(BaseEvent eEvent)
{
Debug.Log("----------------------trace BaseEvent-----------------------------:" + eEvent.GetType());
IDictionaryEnumerator a = eEvent.Params.GetEnumerator();
while (a.MoveNext())
{
Debug.Log("key:" + a.Key);
SFSObject o = a.Value as SFSObject;
Debug.Log(o != null ? o.GetDump() : a.Value);
}
Debug.Log("=====================trace BaseEvent end===========================");
}
public async Task <AggregateApplicationResult> ApplyEventAsync(BaseEvent evt)
{
// Lets have a constraint for item Name uniqueness
ItemAggregate aggregate;
BaseItemEvent itemEvent;
switch (evt)
{
case ItemCreatedEvent created:
var itemsWithSameName = await aggregatesRepository.GetByNameAsync(created.Name);
if (itemsWithSameName.Any(x => x.LastEvent != null && !(x.LastEvent is ItemDeletedEvent)))
{
return(new ItemAlreadyExistsApplicationResult("Item with the same name already exists"));
}
aggregate = new ItemAggregate(created.ItemId);
itemEvent = created;
break;
case ItemDeletedEvent deleted:
aggregate = await aggregatesRepository.GetByIdAsync(deleted.ItemId);
if (aggregate == null || aggregate.LastEvent == null)
{
return(new ItemNotFoundApplicationResult());
}
if (aggregate.LastEvent is ItemDeletedEvent)
{
// It is already deleted
return(new SuccessAggregateApplicationResult());
}
itemEvent = deleted;
break;
case ItemUpdatedEvent updated:
aggregate = await aggregatesRepository.GetByIdAsync(updated.ItemId);
if (aggregate == null || aggregate.LastEvent == null || aggregate.LastEvent is ItemDeletedEvent)
{
return(new ItemNotFoundApplicationResult());
}
if (aggregate.LastEvent is ItemUpdatedEvent lastUpdated && lastUpdated.Name.Equals(updated.Name))
{
// This aggregate has already got this name
return(new SuccessAggregateApplicationResult());
}
// Looking for another aggregate with this name
var itemsWithSameNameForUpdate = await aggregatesRepository.GetByNameAsync(updated.Name);
if (itemsWithSameNameForUpdate.Any(x => x.LastEvent != null && !(x.LastEvent is ItemDeletedEvent)))
{
return(new ItemAlreadyExistsApplicationResult("Item with the same name already exists"));
}
itemEvent = updated;
break;
default:
return(new FailedAggregateApplicationResult($"Specified event type {evt.GetType().Name} is not supported"));
}
var applicationResult = aggregate.ApplyEvent(itemEvent);
switch (applicationResult)
{
case SuccessAggregateApplicationResult success:
// This method might be a root specific, because of several aggregate repositories might be impacted by one event
this.stagedAggregates.Add(aggregate);
break;
}
return(applicationResult);
}
private async Task SendEvent(BaseEvent @event)
{
_messageSession = (IMessageSession)_serviceProvider.GetService(typeof(IMessageSession));
await _messageSession.Publish(@event);
_logger.LogInformation("----- Published {IntegrationEventName}: {IntegrationEventId} from {AppName} - ({@IntegrationEvent})", @event.GetType().Name, @event.Id, Program.AppName, @event);
}
/// <summary>
/// Send the given event to all event sinks
/// </summary>
private void SendEvent(IDebugCoreServer2 server, IDebugPort2 port, IDebugProcess2 process, IDebugProgram2 program, BaseEvent @event)
{
var iid = @event.IID;
DLog.Debug(DContext.VSDebuggerEvent, "DebugPort Event {0} {1}", @event.GetType().Name, iid);
foreach (var eventSink in eventSinks)
{
var events = eventSink as IDebugPortEvents2;
if (events != null)
{
var rc = events.Event(server, port, process, program, @event, ref iid);
if (!ErrorHandler.Succeeded(rc))
{
DLog.Error(DContext.VSDebuggerEvent, "DebugPort Event failed {0}", rc);
}
}
}
}
