public SessionSummaryDto CalculateWorkoutSummary(SessionDto session, List<DetectedInterval> detectedIntervals, int unit)
{
var sessionSummaryDtoList = new List<SessionSummaryDto>();
for (var w = 0; w < detectedIntervals.Count; w++)
{
var sessionDataSubsetDto = new SessionDataSubsetDto()
{
MinimumSecond = (double)detectedIntervals[w].StartTime,
MaximumSecond = (double)detectedIntervals[w].FinishTime,
SessionId = session.Id,
Unit = unit
};
var sessionSummaryDto = GetSessionDataSubset(sessionDataSubsetDto);
sessionSummaryDtoList.Add(sessionSummaryDto);
}
var totalCount = sessionSummaryDtoList.Count();
// calculate speed
var averageSpeed = Math.Round(sessionSummaryDtoList.Sum(x => x.AverageSpeed) / totalCount, 2, MidpointRounding.AwayFromZero);
var maximumSpeed = sessionSummaryDtoList.MaxBy(s => s.MaximumSpeed).MaximumSpeed;
// calculate distance
var totalDistance = Math.Round(sessionSummaryDtoList.Sum(x => x.TotalDistance), 2, MidpointRounding.AwayFromZero);
// calculate altitiude
var averageAltitude = Math.Round(sessionSummaryDtoList.Sum(x => x.AverageAltitude) / totalCount, 2, MidpointRounding.AwayFromZero);
var maximumAltitude = sessionSummaryDtoList.MaxBy(s => s.MaximumAltitude).MaximumAltitude;
// calculate heart rate
var averageHeartRate = Math.Round(sessionSummaryDtoList.Sum(x => x.AverageHeartRate / totalCount), 2, MidpointRounding.AwayFromZero);
var minimumHeartRate = sessionSummaryDtoList.MinBy(s => s.MinimumHeartRate).MinimumHeartRate;
var maximumHeartRate = sessionSummaryDtoList.MinBy(s => s.MaximumHeartRate).MaximumHeartRate;
// calculate power
var averagePower = Math.Round(sessionSummaryDtoList.Sum(x => x.AveragePower) / totalCount, 2, MidpointRounding.AwayFromZero);
var maximumPower = sessionSummaryDtoList.MaxBy(s => s.MaximumPower).MaximumPower;
// calculate cadence
var averageCadence = Math.Round(sessionSummaryDtoList.Sum(x => x.AverageCadence) / totalCount, 2, MidpointRounding.AwayFromZero);
var maximumCadence = sessionSummaryDtoList.MaxBy(s => s.MaximumCadence).MaximumCadence;
var workoutSummary = new SessionSummaryDto()
{
AverageAltitude = averageAltitude,
MaximumAltitude = maximumAltitude,
AverageHeartRate = averageHeartRate,
MinimumHeartRate = minimumHeartRate,
MaximumHeartRate = maximumHeartRate,
AveragePower = averagePower,
MaximumPower = maximumPower,
AverageCadence = averageCadence,
MaximumCadence = maximumCadence,
AverageSpeed = averageSpeed,
MaximumSpeed = maximumSpeed,
TotalDistance = totalDistance,
Date = session.Date,
SessionId = session.Id
};
return workoutSummary;
}
public SessionSummaryDto GetSingleIntervalSummary(SessionDataSubsetDto sessionDataSubsetDto)
{
var singleIntervalSummary = GetSessionDataSubset(sessionDataSubsetDto);
return singleIntervalSummary;
}
public SessionSummaryDto GetSessionDataSubset(SessionDataSubsetDto sessionDataSubsetDto)
{
var minimumSeconds = sessionDataSubsetDto.MinimumSecond;
var maximumSeconds = sessionDataSubsetDto.MaximumSecond;
var totalTimeInHours = (maximumSeconds - minimumSeconds) / 3600;
var requestedUnitIsMetric = sessionDataSubsetDto.Unit == 0;
var session = _context.Sessions.Single(x => x.Id == sessionDataSubsetDto.SessionId);
var sModeIsMetric = session.SMode.ToString("D9").IsMetric(); // pad int to 9 decimals if zero
var sessionData = _context.SessionData.Where(x => x.SessionId == sessionDataSubsetDto.SessionId).ToList().OrderBy(x => x.Row)
.Select(sd => new SessionDataDto()
{
Id = sd.Id,
HeartRate = sd.HeartRate,
Speed = sd.Speed,
Cadence = sd.Cadence,
Altitude = sd.Altitude,
Power = sd.Power,
SessionId = sd.SessionId,
Date = DateFormat.CalculateSessionDataRowDate(session.Date, session.Interval, sd.Row)
}).ToList();
var filteredSessionData = sessionData.FilterListDates(session.Date, minimumSeconds, maximumSeconds); // filter sessions by min and max seconds
var totalCount = filteredSessionData.Count();
double maximumSpeed;
double averageSpeed;
double totalSpeed;
double totalDistance;
double averageAltitude;
double maximumAltitude;
double totalAltitude;
if (requestedUnitIsMetric) // return metric values
{
if (sModeIsMetric)
{
// calculate speed - divided speed by 10 as speed is *10 in file
totalSpeed = filteredSessionData.Sum(s => s.Speed);
averageSpeed = Math.Round((totalSpeed / 10) / totalCount, 2, MidpointRounding.AwayFromZero);
maximumSpeed = Math.Round(filteredSessionData.MaxBy(s => s.Speed).Speed / 10, 2, MidpointRounding.AwayFromZero);
// calculate distance
totalDistance = Math.Round(averageSpeed * totalTimeInHours, 2, MidpointRounding.AwayFromZero);
// calculate altitiude
totalAltitude = filteredSessionData.Sum(s => s.Altitude / 10);
averageAltitude = Math.Round(totalAltitude / totalCount, 2, MidpointRounding.AwayFromZero);
maximumAltitude = Math.Round(filteredSessionData.MaxBy(s => s.Altitude).Altitude / 10, 2, MidpointRounding.AwayFromZero);
}
else
{
// calculate speed - divided speed by 10 as speed is *10 in file - converted kilometres to miles
totalSpeed = filteredSessionData.Sum(s => s.Speed);
averageSpeed = ((totalSpeed / 10) / totalCount).ConvertToKilometres();
maximumSpeed = (filteredSessionData.MaxBy(s => s.Speed).Speed / 10).ConvertToKilometres();
// calculate distance
totalDistance = ((totalSpeed / 10) / totalCount * totalTimeInHours).ConvertToKilometres();
// calculate altitiude - convert metres to feet
totalAltitude = filteredSessionData.Sum(s => s.Altitude / 10);
averageAltitude = (totalAltitude / totalCount).ConvertToMetres();
maximumAltitude = (filteredSessionData.MaxBy(s => s.Altitude).Altitude / 10).ConvertToMetres();
}
}
else // return imperial values
{
if (sModeIsMetric)
{
// calculate speed - divided speed by 10 as speed is *10 in file - converted kilometres to miles
totalSpeed = filteredSessionData.Sum(s => s.Speed);
averageSpeed = ((totalSpeed / 10) / totalCount).ConvertToMiles();
maximumSpeed = (filteredSessionData.MaxBy(s => s.Speed).Speed / 10).ConvertToMiles();
// calculate distance
totalDistance = ((totalSpeed / 10) / totalCount * totalTimeInHours).ConvertToMiles();
// calculate altitiude - convert metres to feet
totalAltitude = filteredSessionData.Sum(s => s.Altitude / 10);
averageAltitude = (totalAltitude / totalCount).ConvertToFeet();
maximumAltitude = (filteredSessionData.MaxBy(s => s.Altitude).Altitude / 10).ConvertToFeet();
}
else
{
// calculate speed - divided speed by 10 as speed is *10 in file
totalSpeed = filteredSessionData.Sum(s => s.Speed);
averageSpeed = Math.Round((totalSpeed / 10) / totalCount, 2, MidpointRounding.AwayFromZero);
maximumSpeed = Math.Round(
filteredSessionData.MaxBy(s => s.Speed).Speed / 10, 2, MidpointRounding.AwayFromZero);
// calculate distance
totalDistance = Math.Round(averageSpeed * totalTimeInHours, 2, MidpointRounding.AwayFromZero);
// calculate altitiude
totalAltitude = filteredSessionData.Sum(s => s.Altitude / 10);
averageAltitude = Math.Round(totalAltitude / totalCount, 2, MidpointRounding.AwayFromZero);
maximumAltitude = Math.Round(filteredSessionData.MaxBy(s => s.Altitude).Altitude / 10, 2, MidpointRounding.AwayFromZero);
}
}
// calculate heart rate
var totalHeartRate = filteredSessionData.Sum(s => s.HeartRate);
var averageHeartRate = Math.Round(totalHeartRate / totalCount, 2, MidpointRounding.AwayFromZero);
var minimumHeartRate = filteredSessionData.MinBy(s => s.HeartRate).HeartRate;
var maximumHeartRate = filteredSessionData.MaxBy(s => s.HeartRate).HeartRate;
// calculate power
var totalPower = filteredSessionData.Sum(s => s.Power);
var averagePower = Math.Round(totalPower / totalCount, 2, MidpointRounding.AwayFromZero);
var maximumPower = Math.Round(filteredSessionData.MaxBy(s => s.Power).Power, 2, MidpointRounding.AwayFromZero);
// calculate cadence
var totalCadence = filteredSessionData.Sum(s => s.Cadence);
var averageCadence = Math.Round(totalCadence / totalCount, 2, MidpointRounding.AwayFromZero);
var maximumCadence = Math.Round(filteredSessionData.MaxBy(s => s.Cadence).Cadence, 2, MidpointRounding.AwayFromZero);
// calculate normalized power
var filteredSessionDto = new SessionDto()
{
Interval = session.Interval,
SessionData = filteredSessionData
};
var normalizedPower = filteredSessionDto.CalculateNormalizedPower();
// calculate intensity factor
var functionalThresholdPower = _context.Athletes.Single(a => a.Id == session.AthleteId).FunctionalThresholdPower;
var intensityFactor = normalizedPower.CalculateIntensityFactor(functionalThresholdPower);
// calculate training stress score
var sessionTimeInSeconds = filteredSessionData.Count * filteredSessionDto.Interval; //session.Length.TimeOfDay.TotalSeconds;
double trainingStressScore = 0;
string trainingStressScoreStatus = "";
if (normalizedPower != 0)
{
trainingStressScore = Metrics.CalculateTrainingStressScore(sessionTimeInSeconds, normalizedPower, intensityFactor, functionalThresholdPower);
trainingStressScoreStatus = Metrics.TrainingStressScoreStatus(trainingStressScore);
}
var sessionSummaryDto = new SessionSummaryDto()
{
AverageAltitude = averageAltitude,
MaximumAltitude = maximumAltitude,
AverageHeartRate = averageHeartRate,
MinimumHeartRate = minimumHeartRate,
MaximumHeartRate = maximumHeartRate,
AveragePower = averagePower,
MaximumPower = maximumPower,
AverageCadence = averageCadence,
MaximumCadence = maximumCadence,
AverageSpeed = averageSpeed,
MaximumSpeed = maximumSpeed,
TotalDistance = totalDistance,
NormalizedPower = normalizedPower,
IntensityFactor = intensityFactor,
TrainingStressScore = trainingStressScore,
TrainingStressScoreStatus = trainingStressScoreStatus,
Date = session.Date,
SessionId = session.Id
};
return sessionSummaryDto;
}
public void SubsetOfSessionDataShouldBeReturnedForSpecifiedSeconds()
{
var sessionDataSubsetdto = new SessionDataSubsetDto()
{
MinimumSecond = 2,
MaximumSecond = 4,
SessionId = 1
};
var filteredDates = _sessionRepository.GetSessionDataSubset(sessionDataSubsetdto);
var averageSpeed = filteredDates.AverageSpeed;
var averageHeartRate = filteredDates.AverageHeartRate;
var averageAltitude = filteredDates.AverageAltitude;
var averagePower = filteredDates.AveragePower;
Assert.AreEqual(29.63, averageSpeed);
Assert.AreEqual(132.0, averageHeartRate);
Assert.AreEqual(3.2, averageAltitude);
Assert.AreEqual(704.33, averagePower);
}
public HttpResponseMessage GetSingleIntervalSummary(HttpRequestMessage request, SessionDataSubsetDto sessionDataSubsetDto)
{
return CreateHttpResponse(request, () =>
{
var intervalSummary = _sessionRepository.GetSingleIntervalSummary(sessionDataSubsetDto);
HttpResponseMessage response = request.CreateResponse(HttpStatusCode.OK, intervalSummary);
return response;
});
}
public HttpResponseMessage GetSessionDataSubset(HttpRequestMessage request, SessionDataSubsetDto sessionDataSubsetDto)
{
return CreateHttpResponse(request, () =>
{
var sessionSummaryDto = _sessionRepository.GetSessionDataSubset(sessionDataSubsetDto);
HttpResponseMessage response = request.CreateResponse(HttpStatusCode.OK, sessionSummaryDto);
return response;
});
}