public override IQueryable <Event> Filter(IQueryable <Event> source)
{
var working = source;
if (IncidentId.HasValue)
{
working = working.Where(ev => ev.IncidentId == IncidentId);
}
if (EventTypes != null && EventTypes.Length > 0)
{
working = working.Where(ev => EventTypes.Contains(ev.EventTypeId));
}
if (Occurred.HasValue)
{
working = working.Where(ev => ev.Occurred == Occurred);
}
if (EventFired.HasValue)
{
working = working.Where(ev => ev.EventFired == EventFired);
}
if (!String.IsNullOrEmpty(DataKey))
{
var workingCompare = String.IsNullOrEmpty(DataValue)
? String.Format(KeyComparison, DataKey)
: String.Format(KeyValueComparison, new string[] { DataKey, DataValue });
working = working.Where(obj => obj.Data.Contains(workingCompare));
}
return(working);
}
// ------------------------------
#endregion
#region Event wiring
// ------------------------------
void Ensure(ServiceEnvironmentEventType eventType)
{
if (!EventTypes.Contains(eventType))
{
throw new InvalidOperationException(String.Format("Cannot connect listener to event {0} because it is not registered to receive this event.", eventType));
}
}
public bool IsMatchFor(Data.Incidents.Models.Event toCompare)
{
if (IncidentId.HasValue && toCompare.IncidentId != IncidentId.Value)
{
return(false);
}
if (EventTypes != null && EventTypes.Length > 0 && !EventTypes.Contains(toCompare.EventTypeId))
{
return(false);
}
if (StartTime.HasValue && toCompare.Occurred.CompareTo(StartTime) <= 0)
{
return(false);
}
if (EndTime.HasValue && toCompare.Occurred.CompareTo(EndTime) > 0)
{
return(false);
}
if (!String.IsNullOrEmpty(DataKey))
{
if (String.IsNullOrEmpty(DataValue))
{
if (!toCompare.Data.Contains(String.Format(KeyComparison, DataKey)))
{
return(false);
}
}
else
{
if (!toCompare.Data.Contains(String.Format(KeyValueComparison, new string[] { DataKey, DataValue })))
{
return(false);
}
}
}
if (!string.IsNullOrEmpty(DataSearch) && (toCompare.Data == null || !toCompare.Data.Contains(DataSearch)))
{
return(false);
}
return(true);
}
public override void UpdateEventTypesAndTimers()
{
IEnumerable <EventType> dashboardtypes = new List <EventType> ();
IEnumerable <EventType> timelinetypes;
if (Dashboard != null)
{
/* Timers */
IEnumerable <LMTimer> timers = Dashboard.List.OfType <TimerButton> ().Select(b => b.Timer).OfType <LMTimer> ();
Timers.AddRange(timers.Except(Timers));
/* Update event types list that changes when the user adds or remove a
* a new button to the dashboard or after importing a project with events
* tagged with a different dashboard */
dashboardtypes = Dashboard.List.OfType <EventButton> ().Select(b => b.EventType);
}
/* Remove event types that have no events and are not in the dashboard anymore */
foreach (EventType evt in EventTypes.Except(dashboardtypes).ToList())
{
if (evt == SubstitutionsEventType)
{
continue;
}
if (Timeline.Count(e => e.EventType == evt) == 0)
{
EventTypes.Remove(evt);
}
}
EventTypes.AddRange(dashboardtypes.Except(EventTypes));
timelinetypes = Timeline.Select(t => t.EventType).Distinct().Except(EventTypes);
EventTypes.AddRange(timelinetypes.Except(EventTypes));
if (!EventTypes.Contains(SubstitutionsEventType))
{
EventTypes.Add(SubstitutionsEventType);
}
/* Remove null EventTypes just in case */
EventTypes = new RangeObservableCollection <EventType> (EventTypes.Where(e => e != null));
}
public void Subscribe <TEvent, TEventHandler>()
where TEvent : Domain.Core.Events.Event
where TEventHandler : Domain.Core.Bus.IEventHandler <TEvent>
{
try
{
string eventTypeName = typeof(TEvent).Name;
System.Type eventHandlerType = typeof(TEventHandler);
if (EventTypes.Contains(typeof(TEvent)) == false)
{
EventTypes.Add(typeof(TEvent));
}
if (EventHandlerTypes.ContainsKey(eventTypeName) == false)
{
EventHandlerTypes.Add(eventTypeName,
new System.Collections.Generic.List <System.Type>());
}
if (EventHandlerTypes[eventTypeName].Any(current => current.GetType() == eventHandlerType))
{
string errorMessage =
$"Handler Type '{ eventHandlerType.Name }' already is registered for '{ eventTypeName }'!";
throw new System.ArgumentException
(message: errorMessage, paramName: nameof(eventHandlerType));
}
EventHandlerTypes[eventTypeName].Add(eventHandlerType);
StartBasicConsume <TEvent>();
}
catch (System.Exception ex)
{
System.Console.WriteLine(ex.Message);
}
}
public bool Matches(DeviceEventType eventType)
{
var result = EventTypes.Contains(eventType);
return(result);
}
