private void ProcessValues(IEventPattern e, PatternTestResultEventPattern re)
{
#region Value
if (e.Options.Value)
{
var prop = PropertyService.GetProperty(new LineArgs
{
Path = _path,
iLine = e.iLine,
Line = e.Line
});
foreach (var valueName in e.Options.ValueParameters)
{
var value = prop.FindPropertyValue(valueName);
if (value != null)
{
var v = new NameValue()
{
Name = valueName,
Value = value,
Type = Model.IDE.ValueType.Value
};
re.Values.Add(v);
}
}
}
#endregion
}
private void AddEvent(List <PatternTestResultEventPattern> model, List <DurationColumn> stops, List <DurationColumn> durationPattern,
TimeSpan baselineMin, TimeSpan BaselineMax, int max, PatternTestResultEventPattern eventPattern)
{
for (int i = 0; i < max; i++)
{
eventPattern.DurationPatternForExcel.Add(stops.Any(n => n.Column == i));
}
eventPattern.BaselineMin = baselineMin;
eventPattern.BaselineMax = BaselineMax;
// Add Time for Duration Outside or Inside
switch (eventPattern.EventType)
{
case EventType.GapOutside:
case EventType.GapInside:
var _leftFound = false;
foreach (var stop in stops)
{
var c = durationPattern[stop.Column];
if (!_leftFound)
{
_leftFound = true;
switch (eventPattern.EventType)
{
case EventType.GapOutside:
c.DurationOutsideOfDuration = c.DurationOutsideOfDuration.Add(eventPattern.IdleTimeOutsideOfDuration);
break;
case EventType.GapInside:
c.DurationOutsideOfDuration = c.DurationOutsideOfDuration.Add(eventPattern.IdleTimeInsideOfDuration);
break;
default:
throw new Exception("EventType not supported!");
}
}
else
{
switch (eventPattern.EventType)
{
case EventType.GapOutside:
c.DurationInsideOfDuration = c.DurationOutsideOfDuration.Add(eventPattern.IdleTimeOutsideOfDuration);
break;
case EventType.GapInside:
c.DurationInsideOfDuration = c.DurationInsideOfDuration.Add(eventPattern.IdleTimeInsideOfDuration);
break;
default:
throw new Exception("EventType not supported!");
}
}
}
break;
}
model.Add(eventPattern);
}
private static string GetColumnName(PatternTestResultEventPattern pe)
{
switch (pe.EventType)
{
case EventType.Start:
case EventType.Body:
case EventType.Stop:
case EventType.Reset:
case EventType.Search:
case EventType.Restart:
return(pe.Name);
case EventType.TotalTime:
return(TOTALTIME);
case EventType.GapOutside:
case EventType.GapInside:
return(TIMEGAP);
case EventType.TotalIdleTime:
return(TOTALIDLETIME);
case EventType.MaxOverlaps:
return(MAXOVERLAPS);
case EventType.TotalOverlappingTime:
return(TOTALOVERLAPPING);
case EventType.Warning:
return(WARNING);
case EventType.Duration:
return(DURATION);
default:
throw new Exception("Unknown EventType");
}
}
private void AddEvent(List <PatternTestResultEventPattern> model, List <DurationColumn> stops, List <DurationColumn> durationPattern,
int max, PatternTestResultEventPattern eventPattern)
{
AddEvent(model, stops, durationPattern, new TimeSpan(), new TimeSpan(), max, eventPattern);
}
private TimeSpan IdleTimePostProcess(PatternTestResult p)
{
var model = new List <PatternTestResultEventPattern>();
PatternTestResultEventPattern prior = null;
DateTime startGAP = DateTime.MinValue;
var _durationStops = new List <DurationColumn>();
var _durationPattern = PrepareDurationPattern(p);
var _maxDurationPatterns = _durationPattern.Count();
var _totalKnownIdle = new TimeSpan();
var _totalKnownIdleEvents = new List <PatternTestResultEventPattern>();
var _totalUnknownIdle = new TimeSpan();
var _totalUnKnownIdleEvents = new List <PatternTestResultEventPattern>();
// TODO: We need to move CleanPlaceholders to their own list and then reference them when we are ready. - Sara
// The issue is that we have added it to Events, and Events is processed, Thus the PlaceHolders are going throug that process when we don't want them too.
// Better to have their own list and then when needed, reference them for 'Clean'
foreach (var e in p.Events)
{
////
// Idle Time from Prior EventPattern
////
if (prior != null &&
e.DateTime.HasValue &&
e.DateTime != startGAP &&
!e.Options.Hide &&
!prior.Options.BodyStop)
{
var _duration = e.DateTime.Value - startGAP;
var _caption = " - Idle Time*";
var _eventType = EventType.GapInside;
if (!_durationStops.Any())
{
_caption = $" - Idle Time ({prior.Name} to {e.Name})";
_eventType = EventType.GapOutside;
_totalUnknownIdle = _totalUnknownIdle.Add(_duration);
}
var ne = new PatternTestResultEventPattern($"{_duration.ToFixedTimeString()}{_caption}",
_eventType,
p.Path,
prior.EndiLine,
e.EndiLine,
null,
e.DateTime,
_duration);
// GAP -
AddEvent(model, _durationStops, _durationPattern, _maxDurationPatterns, ne);
if (!_durationStops.Any())
{
_totalUnKnownIdleEvents.Add(ne);
}
}
// Duration has started
if (e.DurationStopIdentifiers.Count > 0)
{
foreach (var ds in e.DurationStopIdentifiers)
{
_durationStops.Add(_durationPattern.FirstOrDefault(n => n.Start == e.Identifier && n.Stop == ds));
}
}
AddEvent(model, _durationStops, _durationPattern, _maxDurationPatterns, e.Clone());
var tempStops = _durationStops.Where(n => n.Stop == e.Identifier).ToList();
if (!e.Options.Hide &&
!(prior != null && prior.Options.BodyStop))
{
foreach (var di in e.Values.Where(n => n.Type != Model.IDE.ValueType.Value))
{
switch (di.Type)
{
case ValueType.TimeTo:
case ValueType.TimeToNext:
case ValueType.TimeToNextKnownIdle:
// Duration has ended
// If the EventPattern Identifier is in _durationEvents, then the Duration has ended and it should be removed.
// Note: The given Identifier may be in the list more then once, if there are multiple durations that are ending.
_durationStops.RemoveAll(n => n.Stop == e.Identifier);
break;
case ValueType.TimeFrom:
if (_durationStops.Any(n => n.Stop == e.Identifier))
{
_durationStops.AddRange(tempStops);
}
break;
}
if (di.Value is TimeSpan _d)
{
var eventName = string.Empty;
if (!string.IsNullOrEmpty(e.Name))
{
eventName = $"[{e.Name}] ";
}
var m = new PatternTestResultEventPattern($"{_d.ToFixedTimeString()} - {eventName}Duration:{di.Name}",
di.Type == ValueType.TimeToNextKnownIdle ? EventType.IdleDuration : EventType.Duration,
p.Path,
p.Events.FirstOrDefault(n => n.Identifier == di.StartIdentifier).StartiLine,
p.Events.FirstOrDefault(n => n.Identifier == di.StopIdentifier).StartiLine,
null,
e.DateTime,
_d)
{
DurationStartIdentifier = di.StartIdentifier,
DurationStopIdentifier = di.StopIdentifier,
EventName = e.Name,
};
var _duration = (TimeSpan)di.Value;
if (di.BaselineMin.Ticks == 0 && di.BaselineMax.Ticks == 0)
{
m.NoBaseline = true;
}
else if (_duration < di.BaselineMin || _duration > di.BaselineMax)
{
m.OutsideBaseline = true;
}
else
{
m.WithinBaseline = true;
}
AddEvent(model, _durationStops, _durationPattern, di.BaselineMin, di.BaselineMax, _maxDurationPatterns, m);
if (di.Type == ValueType.TimeToNextKnownIdle)
{
_totalKnownIdle = _totalKnownIdle.Add(_d);
_totalKnownIdleEvents.Add(m);
}
}
}
}
// Duration has ended
// If the EventPattern Identifier is in _durationEvents, then the Duration has ended and it should be removed.
// Note: The given Identifier may be in the list more then once, if there are multiple durations that are ending.
_durationStops.RemoveAll(n => n.Stop == e.Identifier);
if (e.DateTime.HasValue && !e.Options.Hide)
{
startGAP = e.DateTime.Value;
}
prior = e;
}
if (p.Options.KnownIdle)
{
var m = new PatternTestResultEventPattern($"{_totalKnownIdle.ToFixedTimeString()} - [Known Idle] Duration",
EventType.IdleDuration,
p.Path,
p.StartiLine,
p.StartiLine,
null,
p.Events[0].DateTime,
_totalKnownIdle)
{
DurationStartIdentifier = p.Events[0].Identifier,
DurationStopIdentifier = p.Events[0].Identifier,
EventName = "Known Idle",
ChildEvents = _totalKnownIdleEvents
};
var parameters = p.Options.KnownIdleParameters.ToBaseLineList();
if (parameters.Count == 1)
{
var _min = parameters[0].Min;
var _max = parameters[0].Max;
if (_min.Ticks == 0 && _max.Ticks == 0)
{
m.NoBaseline = true;
}
else if (_totalKnownIdle < _min || _totalKnownIdle > _max)
{
m.OutsideBaseline = true;
}
else
{
m.WithinBaseline = true;
}
AddEvent(model, _durationStops, _durationPattern, _min, _max, _maxDurationPatterns, m);
}
}
if (p.Options.UnknownIdle)
{
var m = new PatternTestResultEventPattern($"{_totalUnknownIdle.ToFixedTimeString()} - [Unknown Idle] Duration",
EventType.IdleDuration,
p.Path,
p.StartiLine,
p.StartiLine,
null,
p.Events[0].DateTime,
_totalUnknownIdle)
{
DurationStartIdentifier = p.Events[0].Identifier,
DurationStopIdentifier = p.Events[0].Identifier,
EventName = "Unknown Idle",
ChildEvents = _totalUnKnownIdleEvents,
Duration = _totalUnknownIdle
};
var parameters = p.Options.UnknownIdleParameters.ToBaseLineList();
if (parameters.Count == 1)
{
var _min = parameters[0].Min;
var _max = parameters[0].Max;
if (_min.Ticks == 0 && _max.Ticks == 0)
{
m.NoBaseline = true;
}
else if (_totalUnknownIdle < _min || _totalUnknownIdle > _max)
{
m.OutsideBaseline = true;
}
else
{
m.WithinBaseline = true;
}
AddEvent(model, _durationStops, _durationPattern, _min, _max, _maxDurationPatterns, m);
}
}
ProcessDurationOutsideInside(model, _durationPattern);
p.Events = model;
return(_totalUnknownIdle);
}
private void ProcessDuration(List <IEventPattern> events, List <PatternTestResultEventPattern> sourceEvents, IEventPattern eventPattern, PatternTestResultEventPattern re)
{
#region TimeToNextKnownIdle
if (eventPattern.Options.TimeToNextKnownIdle)
{
var _baseLine = eventPattern.Options.TimeToNextKnownIdleParameters.ToBaseLineList().First();
var nextEvent = GetNextEvent(events, eventPattern);
if (nextEvent != null &&
eventPattern.DateTime.HasValue &&
nextEvent.DateTime.HasValue)
{
re.DurationStopIdentifiers.Add(nextEvent.Identifier);
var v = new NameValue()
{
Name = $"{Keyword._TimeToNextKnownIdle}({nextEvent.EventTag})",
Value = eventPattern.DateTime.Value.Difference(nextEvent.DateTime.Value),
Type = Model.IDE.ValueType.TimeToNextKnownIdle,
StartIdentifier = eventPattern.Identifier,
StopIdentifier = nextEvent.Identifier,
BaselineMin = _baseLine.Min,
BaselineMax = _baseLine.Max
};
// To keep the unique value of the column, do not include time in the name
//if (v.Value is TimeSpan d)
// re.Name = $"{re.Name} - {d.ToShortReadableString()}";
re.Values.Add(v);
}
}
#endregion TimeToNextKnownIdle
#region TimeToNext
if (eventPattern.Options.TimeToNext)
{
var _baseLine = eventPattern.Options.TimeToNextParameters.ToBaseLineList().First();
var nextEvent = GetNextEvent(events, eventPattern);
if (nextEvent != null &&
eventPattern.DateTime.HasValue &&
nextEvent.DateTime.HasValue)
{
re.DurationStopIdentifiers.Add(nextEvent.Identifier);
var v = new NameValue()
{
Name = $"{Keyword._TimeToNext}({nextEvent.EventTag})",
Value = eventPattern.DateTime.Value.Difference(nextEvent.DateTime.Value),
Type = Model.IDE.ValueType.TimeToNext,
StartIdentifier = eventPattern.Identifier,
StopIdentifier = nextEvent.Identifier,
BaselineMin = _baseLine.Min,
BaselineMax = _baseLine.Max
};
// To keep the unique value of the column, do not include time in the name
//if (v.Value is TimeSpan d)
// re.Name = $"{re.Name} - {d.ToShortReadableString()}";
re.Values.Add(v);
}
}
#endregion TimeToNext
#region TimeToOr
if (eventPattern.Options.TimeToOr)
{
// Find the EventPattern that occurs first
EventPattern toEventPattern = null;
EventBaseLine toEventParameter = null;
var parameters = eventPattern.Options.TimeToOrParameters.ToBaseLineList();
foreach (var param in parameters)
{
var tempEvent = GetNextEventByName(events, eventPattern, param.EventName);
if (toEventPattern == null || tempEvent.iLine < toEventPattern.iLine)
{
toEventPattern = tempEvent;
toEventParameter = param;
}
}
if (toEventPattern != null &&
eventPattern.DateTime.HasValue &&
toEventPattern.DateTime.HasValue)
{
re.DurationStopIdentifiers.Add(toEventPattern.Identifier);
var v = new NameValue()
{
Name = $"{Keyword._TimeToOr}({toEventPattern.EventTag})",
Value = eventPattern.DateTime.Value.Difference(toEventPattern.DateTime.Value),
Type = ValueType.TimeToOr,
StartIdentifier = re.Identifier,
StopIdentifier = toEventPattern.Identifier,
BaselineMin = toEventParameter.Min,
BaselineMax = toEventParameter.Max
};
re.Values.Add(v);
}
}
#endregion
#region TimeTo
if (eventPattern.Options.TimeTo)
{
var parameters = eventPattern.Options.TimeToParameters.ToBaseLineList();
foreach (var param in parameters)
{
var toEvent = GetNextEventByName(events, eventPattern, param.EventName);
if (toEvent != null &&
eventPattern.DateTime.HasValue &&
toEvent.DateTime.HasValue)
{
re.DurationStopIdentifiers.Add(toEvent.Identifier);
var v = new NameValue()
{
Name = $"{Keyword._TimeTo}({toEvent.EventTag})",
Value = eventPattern.DateTime.Value.Difference(toEvent.DateTime.Value),
Type = ValueType.TimeTo,
StartIdentifier = re.Identifier,
StopIdentifier = toEvent.Identifier,
BaselineMin = param.Min,
BaselineMax = param.Max
};
re.Values.Add(v);
}
}
}
#endregion
#region TimeFrom
if (eventPattern.Options.TimeFrom)
{
var parameters = eventPattern.Options.TimeFromParameters.ToBaseLineList();
foreach (var param in parameters)
{
var fromEvent = GetPriorEventByName(events, eventPattern, param.EventName);
if (fromEvent != null &&
eventPattern.DateTime.HasValue &&
fromEvent.DateTime.HasValue)
{
FindEventResult(fromEvent, sourceEvents).DurationStopIdentifiers.Add(re.Identifier);
var v = new NameValue()
{
Name = $"{Keyword._TimeFrom}({fromEvent.EventTag})",
Value = fromEvent.DateTime.Value.Difference(eventPattern.DateTime.Value),
Type = ValueType.TimeFrom,
StartIdentifier = fromEvent.Identifier,
StopIdentifier = eventPattern.Identifier,
BaselineMin = param.Min,
BaselineMax = param.Max
};
re.Values.Add(v);
}
}
}
#endregion
}
private void AddResult(PatternComplex r)
{
var p = new PatternTestResult
{
Name = r.Name,
PatternName = r.Name,
Path = _path,
StartiLine = r.Events.Any() ? r.Events.First(n => n.Found).iLine : 0,
EndiLine = r.Events.Any() ? r.Events.Last(n => n.Found).iLine : 0,
Warnings = r.Warnings,
TotalDuration = r.TotalDuration,
Options = r.Options.Clone()
};
r.Events = r.Events.OrderBy(n => n.iLine).ToList();
foreach (var e in r.Events.Where(n => n.Found))
{
e.Path = _path;
#region Process Search
if (e.EventType == EventType.Search)
{
_result.Log.Add($@"{DateTime.Now.ToShortTimeString()} Pattern Search EventPattern ""{e.EventTag}"" found {e.iLineSearchMatches.Count} matches.");
foreach (var i in e.iLineSearchMatches)
{
var res = new PatternTestResultEventPattern(e, i.iLine);
e.iLine = i.iLine;
e.Line = i.Line;
ProcessValues(e, res);
p.Events.Add(res);
}
continue;
}
#endregion Process Search
var re = new PatternTestResultEventPattern(e, e.iLine);
ProcessDuration(r.Events, p.Events, e, re);
ProcessValues(e, re);
p.Events.Add(re);
// TODO: What is this for, should it be moved to a Summary of Totals section? - Sara
#region Process Stop
if (e.BodyStopFound &&
e.DateTime.HasValue &&
e.DateTimeBodyStop.HasValue)
{
var _duration = e.DateTimeBodyStop.Value - e.DateTime;
var b = new PatternTestResultEventPattern($"{_duration.Value.ToFixedTimeString()}",
EventType.Duration,
e.Path,
e.iLineBodyStop,
0,
null,
e.DateTimeBodyStop,
_duration.Value);
p.Events.Add(b);
}
#endregion Process Stop
}
#region Add Processed Pattern to List
p.Events = p.Events.OrderBy(n => n.StartiLine).ToList();
var _summary = _result.PatternSummaries.Where(n => n.PatternName == p.PatternName).FirstOrDefault();
if (_summary == null)
{
_summary = new PatternTestSummary(p.PatternName);
_result.PatternSummaries.Add(_summary);
}
_summary.Patterns.Add(p);
#endregion
}
