public void ProcessEvent(IDEEvent @event)
{
if (@event.ActiveDocument != null && _currentIntervals.ContainsKey(@event.ActiveDocument))
{
_context.AdaptIntervalTimeData(_currentIntervals[@event.ActiveDocument], @event);
}
var documentEvent = @event as DocumentEvent;
if (documentEvent != null && documentEvent.Document != null)
{
if (_currentIntervals.ContainsKey(documentEvent.Document))
{
_context.AdaptIntervalTimeData(_currentIntervals[documentEvent.Document], @event);
if (documentEvent.Action == DocumentAction.Closing)
{
_intervals.Add(_currentIntervals[documentEvent.Document]);
_currentIntervals.Remove(documentEvent.Document);
}
}
else
{
if (documentEvent.Action == DocumentAction.Opened)
{
_currentIntervals[documentEvent.Document] =
_context.CreateIntervalFromEvent <FileOpenInterval>(@event);
_currentIntervals[documentEvent.Document].FileName = documentEvent.Document.FileName;
}
}
}
}
private void CreateNewInterval(IDEEvent e, FileInteractionType classification)
{
_intervals.Add(_cur = _context.CreateIntervalFromEvent <FileInteractionInterval>(e));
_cur.FileName = e.ActiveDocument.FileName;
_cur.Type = classification;
TransformerUtils.SetDocumentTypeIfNecessary(_cur, e); // initial
}
public void ProcessEvent(IDEEvent e)
{
Asserts.That(e.TriggeredAt.HasValue);
Asserts.That(e.TerminatedAt.HasValue);
if (IsFocusGain(e))
{
_hasFocus = true;
}
if (!_hasFocus)
{
return;
}
if (_cur == null)
{
_intervals.Add(_cur = _context.CreateIntervalFromEvent <VisualStudioActiveInterval>(e));
}
_context.UpdateDurationForIntervalToMaximum(_cur, e.TerminatedAt.Value);
if (IsFocusLost(e))
{
EndCurrentInterval(e);
}
}
public void ProcessEvent(IDEEvent e)
{
if (_intervals.ContainsKey(e.IDESessionUUID))
{
_context.AdaptIntervalTimeData(_intervals[e.IDESessionUUID], e);
}
else
{
_intervals.Add(
e.IDESessionUUID,
_context.CreateIntervalFromEvent <VisualStudioOpenedInterval>(e));
}
}
public void ProcessEvent(IDEEvent e)
{
Asserts.That(e.TriggeredAt.HasValue);
Asserts.That(e.TerminatedAt.HasValue);
var curEnd = e.TerminatedAt.Value;
if (IsTimeout(e))
{
curInt = null;
}
if (curInt == null)
{
_intervals.Add(curInt = _context.CreateIntervalFromEvent <UserActiveInterval>(e));
}
_context.UpdateDurationForIntervalToMaximum(curInt, curEnd);
}
public void ProcessEvent(IDEEvent @event)
{
if (_currentInterval != null &&
_currentInterval.Perspective == PerspectiveType.Production &&
MarksStartOfDebugSession(@event))
{
_currentInterval = null;
}
if (_currentInterval == null)
{
_currentInterval = _context.CreateIntervalFromEvent <PerspectiveInterval>(@event);
if (_currentInterval.StartTime < _referenceTime)
{
_currentInterval.Duration -= _referenceTime - _currentInterval.StartTime;
_currentInterval.StartTime = _referenceTime;
}
_intervals.Add(_currentInterval);
_currentInterval.Perspective = MarksStartOfDebugSession(@event)
? PerspectiveType.Debug
: PerspectiveType.Production;
}
else
{
_context.AdaptIntervalTimeData(_currentInterval, @event);
_referenceTime = @event.TerminatedAt.GetValueOrDefault();
if (MarksEndOfDebugSession(@event))
{
_currentInterval = null;
}
}
}
public void ProcessEvent(IDEEvent @event)
{
Asserts.That(@event.TriggeredAt.HasValue);
var testRunEvent = @event as TestRunEvent;
if (testRunEvent != null)
{
var testsByProject = testRunEvent.Tests.GroupBy(t => t.TestMethod.DeclaringType.Assembly.Name);
foreach (var testProject in testsByProject)
{
var interval = _context.CreateIntervalFromEvent <TestRunInterval>(@event);
interval.ProjectName = testProject.Key;
foreach (var testClass in testProject.GroupBy(p => p.TestMethod.DeclaringType.FullName))
{
var testClassResult = new TestRunInterval.TestClassResult {
TestClassName = testClass.Key
};
var firstStarted = DateTimeOffset.MaxValue;
var lastEnded = DateTimeOffset.MinValue;
foreach (var testMethod in testClass)
{
// TODO untested (
if (testMethod.StartTime.HasValue)
{
var delta =
Math.Round((@event.TriggeredAt.Value - testMethod.StartTime.Value).TotalHours);
var now = DateTime.Now;
var detltaTs = now.AddHours(delta) - now;
testMethod.StartTime = testMethod.StartTime.Value + detltaTs;
}
var startedAt = testMethod.StartTime ?? @event.TriggeredAt.Value;
var endedAt = startedAt + testMethod.Duration;
if (startedAt < firstStarted)
{
firstStarted = startedAt;
}
if (endedAt > lastEnded)
{
lastEnded = endedAt;
}
// )
var testMethodResult = new TestRunInterval.TestMethodResult
{
TestMethodName = testMethod.TestMethod.Name + testMethod.Parameters,
// TODO untested
StartedAt = startedAt,
Duration = testMethod.Duration,
Result = testMethod.Result
};
testClassResult.TestMethods.Add(testMethodResult);
testClassResult.Result = UpdateCumulativeTestResult(
testClassResult.Result,
testMethod.Result);
interval.Result = UpdateCumulativeTestResult(
testClassResult.Result,
testMethod.Result);
}
// untested (
testClassResult.StartedAt = firstStarted;
testClassResult.Duration = lastEnded - firstStarted;
// )
interval.TestClasses.Add(testClassResult);
interval.Duration += testClassResult.Duration;
}
_currentIntervals.Add(interval);
}
}
}