protected virtual void ProcessLiveFeedDataAsync(LiveFeedData liveFeedData)
{
try
{
if (liveFeedData.RaceId != _lastRaceId ||
liveFeedData.RunId != _lastRunId)
{
ResetLapAverages();
_eventLapAverages.RaceId = liveFeedData.RaceId;
_eventLapAverages.RunId = liveFeedData.RunId;
}
ReadLapTimes(liveFeedData);
if (liveFeedData.Elapsed != _lastElapsed)
{
OnLapAveragesUpdated(_eventLapAverages);
_lastElapsed = liveFeedData.Elapsed;
_lastRaceId = liveFeedData.RaceId;
_lastRunId = liveFeedData.RunId;
}
}
catch (Exception ex)
{
ExceptionHandler("Error pumping lap averages", ex);
}
}
protected virtual string GetFileDirectory(string rootDirectory, LiveFeedData data)
{
SeriesType seriesType = (data.SeriesType - 1);
var series = seriesType.ToString();
var track = data.TrackName;
var runName = data.RunName;
var eventDate = DateTime.Now.ToString("MM-dd-yyyy");
var subDirectoryPath = $"{series}\\{track}\\{eventDate}\\{runName}";
foreach (var c in Path.GetInvalidPathChars())
{
subDirectoryPath = subDirectoryPath.Replace(c.ToString(), "");
}
var fullFileDirectory = Path.Combine(rootDirectory, subDirectoryPath);
if (!Directory.Exists(fullFileDirectory))
{
Directory.CreateDirectory(fullFileDirectory);
}
return(fullFileDirectory);
}
public virtual async Task <LapAverageData> ReadLapAveragesAsync(LiveFeedData data)
{
var key = GetKey(data);
var item = await _repository.SelectAsync(key);
return(JsonConvert.DeserializeObject <LapAverageData>(item.Content));
}
protected virtual void ProcessLiveFeedDataAsync(LiveFeedData liveFeedData)
{
try
{
if (_verbose)
{
StringBuilder sb = new StringBuilder();
sb.Append($"Elapsed:{liveFeedData.Elapsed} ");
sb.Append($"SeriesId:{liveFeedData.SeriesType} ");
sb.Append($"RaceId:{liveFeedData.RaceId} ");
sb.AppendLine($"RunId:{liveFeedData.RunId}");
sb.Append($"LapNumber:{liveFeedData.LapNumber} ");
sb.AppendLine($"FlagState:{liveFeedData.FlagState.ToString()}");
Console.WriteLine("------------------");
Console.WriteLine(sb);
}
if (liveFeedData.RaceId != _lastRaceId ||
liveFeedData.SeriesType != _lastSeriesId ||
liveFeedData.RunId != _lastRunId)
{
if (_verbose)
{
Console.WriteLine("Resetting lap times");
}
ResetLapTimes();
_lapTimes.RaceId = liveFeedData.RaceId;
_lapTimes.SeriesId = (int)liveFeedData.SeriesType;
_lapTimes.RunId = liveFeedData.RunId;
_lapTimes.Elapsed = liveFeedData.Elapsed;
_lapTimes.TrackName = liveFeedData.TrackName;
_lapTimes.RunName = liveFeedData.RunName;
}
_lapTimes = ReadLapTimes(liveFeedData);
if (liveFeedData.Elapsed != _lastElapsed)
{
OnLapTimesUpdated(_lapTimes);
_lastElapsed = liveFeedData.Elapsed;
_lastRaceId = liveFeedData.RaceId;
_lastSeriesId = liveFeedData.SeriesType;
_lastRunId = liveFeedData.RunId;
}
}
catch (Exception ex)
{
ExceptionHandler("Error pumping lap times", ex);
}
}
protected virtual string GetFileContent(LiveFeedData data)
{
var fileContent = JsonConvert.SerializeObject(
data,
Formatting.Indented,
new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Include
});
return(fileContent);
}
protected virtual void OnLiveFeedUpdated(LiveFeedData liveFeedData)
{
var handler = LiveFeedUpdated;
if (handler != null)
{
handler.Invoke(this, new LiveFeedUpdatedEventArgs()
{
LiveFeedData = liveFeedData
});
}
}
public void WriteFile(string rootDirectory, LiveFeedData data)
{
var fileDirectory = GetFileDirectory(rootDirectory, data);
var fileTitle = GetFileTitle(data);
var fullFilePath = Path.Combine(fileDirectory, fileTitle);
var fileContent = GetFileContent(data);
File.WriteAllText(fullFilePath, fileContent);
LastElapsedWritten = data.Elapsed;
}
public virtual void UpdateListRowsData(List <List <object> > viewData)
{
var feedDataType = LiveFeedData.GetType();
var gridRows = pnlDetail.Controls
.OfType <ListRow>()
.Where(l => l.Index >= 0)
.OrderBy(l => l.Index)
.ToList();
if (gridRows.Count == 0)
{
return;
}
for (int i = 0; i < gridRows.Count(); i++)
{
ListRow row = gridRows.FirstOrDefault(r => r.Index == i);
if (i < viewData.Count)
{
List <object> dataRow = viewData[i];
for (int x = 0; x < dataRow.Count; x++)
{
var label = row
.Controls
.OfType <Label>()
.FirstOrDefault(r => ((ViewListColumn)r.Tag).Index == x);
var column = ((ViewListColumn)label.Tag);
if (!String.IsNullOrEmpty(column.Format))
{
label.Text = FormatValue(dataRow[x], column.Format);
}
else
{
label.Text = dataRow[x].ToString();
}
}
}
else
{
// More grid rows than data rows
row.ClearColumns();
}
}
}
protected virtual void ReadLapTimes(LiveFeedData liveFeedData)
{
_lapAverageService.ParseVehicleLapData(liveFeedData);
_eventLapAverages.TrackName = liveFeedData.TrackName;
_eventLapAverages.RunName = liveFeedData.RunName;
_eventLapAverages.Elapsed = liveFeedData.Elapsed;
_eventLapAverages.Best5LapAverages = _lapAverageService.GetBestLapAverages(5);
_eventLapAverages.Best10LapAverages = _lapAverageService.GetBestLapAverages(10);
_eventLapAverages.Best20LapAverages = _lapAverageService.GetBestLapAverages(20);
_eventLapAverages.Last5LapAverages = _lapAverageService.GetBestLapAverages(5);
_eventLapAverages.Last10LapAverages = _lapAverageService.GetBestLapAverages(10);
_eventLapAverages.Last20LapAverages = _lapAverageService.GetBestLapAverages(20);
}
public void ParseVehicleLapData(LiveFeedData data)
{
var elapsed = data.Elapsed;
foreach (Vehicle vehicle in data.Vehicles)
{
if (!_vehicleLapHistory.Keys.Contains(vehicle.CarNumber))
{
_vehicleLapHistory.Add(vehicle.CarNumber, new VehicleLapEventHistory()
{
VehicleId = vehicle.CarNumber
});
}
var history = _vehicleLapHistory[vehicle.CarNumber];
var existingLap = history.GetLapEventAt(vehicle.LapsCompleted);
if (existingLap == null)
{
history.AddLapEvent(vehicle.VehicleElapsedTime, vehicle.LapsCompleted, vehicle.LastLapTime);
}
else
{
existingLap.Elapsed = vehicle.VehicleElapsedTime;
existingLap.LapNumber = vehicle.LapsCompleted;
existingLap.LapTime = vehicle.LastLapTime;
}
foreach (PitStop pitStop in vehicle.PitStops)
{
var existingPitStop = history.GetPitStopEventAt(pitStop.PitInElapsed);
if (existingPitStop == null)
{
history.AddPitEvent(pitStop.PitInElapsed, pitStop.PitInLap, pitStop.PitOutElapsed);
}
else
{
if (existingPitStop.PitOutElapsed == 0.0)
{
existingPitStop.PitOutElapsed = pitStop.PitOutElapsed;
}
}
}
}
}
protected virtual EventVehicleLapTimes ReadLapTimes(LiveFeedData liveFeedData)
{
return(_lapTimeParser.ParseLapTimes(_lapTimes, liveFeedData));
}
public EventVehicleLapTimes ParseLapTimes(EventVehicleLapTimes lapTimes, LiveFeedData data)
{
foreach (Vehicle vehicle in data.Vehicles)
{
var existingLap = lapTimes.VehicleLapTimes.FirstOrDefault(l => l.VehicleId == vehicle.CarNumber && l.LapNumber == vehicle.LapsCompleted);
if (existingLap == null)
{
if (_verbose)
{
Console.WriteLine($"Adding lap time for car {vehicle.CarNumber} for lap {vehicle.LapsCompleted}: {vehicle.LastLapTime}");
}
lapTimes.VehicleLapTimes.Add(new VehicleLapTime()
{
VehicleId = vehicle.CarNumber,
LapNumber = vehicle.LapsCompleted,
LapTime = vehicle.LastLapTime,
EventElapsed = data.Elapsed,
VehicleElapsed = vehicle.VehicleElapsedTime,
TrackState = data.FlagState,
VehicleStatus = (VehicleStatus)vehicle.Status
});
}
else
{
if (existingLap.VehicleElapsed != vehicle.VehicleElapsedTime ||
existingLap.LapNumber != vehicle.LapsCompleted ||
existingLap.LapTime != vehicle.LastLapTime ||
existingLap.VehicleStatus != (VehicleStatus)vehicle.Status ||
existingLap.TrackState != data.FlagState)
{
if (_verbose)
{
Console.WriteLine($"Updating lap time for car {vehicle.CarNumber} " +
$"for lap {vehicle.LapsCompleted}: " +
$" from {existingLap.LapTime} to {vehicle.LastLapTime}" +
$" from {existingLap.VehicleStatus} to {((VehicleStatus)vehicle.Status).ToString()}" +
$" from {existingLap.TrackState} to {data.FlagState.ToString()}");
}
existingLap.VehicleElapsed = vehicle.VehicleElapsedTime;
existingLap.LapNumber = vehicle.LapsCompleted;
existingLap.LapTime = vehicle.LastLapTime;
existingLap.VehicleStatus = (VehicleStatus)vehicle.Status;
existingLap.TrackState = data.FlagState;
}
}
//foreach (PitStop pitStop in vehicle.PitStops)
//{
// var existingPitStop = history.GetPitStopEventAt(pitStop.PitInElapsed);
// if (existingPitStop == null)
// {
// history.AddPitEvent(pitStop.PitInElapsed, pitStop.PitInLap, pitStop.PitOutElapsed);
// }
// else
// {
// if (existingPitStop.PitOutElapsed == 0.0)
// {
// existingPitStop.PitOutElapsed = pitStop.PitOutElapsed;
// }
// }
//}
}
return(lapTimes);
}
protected virtual string GetFileTitle(LiveFeedData data)
{
var fileTitle = $"{data.SeriesType}-{data.RaceId}-{data.RunId}-{data.Elapsed}.json";
return(fileTitle);
}
public void WriteFile(LiveFeedData data)
{
WriteFile(RootDirectory, data);
}
protected virtual string GetKey(LiveFeedData data)
{
return($"{data.SeriesType}-{data.RaceId}-{data.RunId}");
}
public virtual List <List <object> > GetViewData()
{
string dataColumnErrorMessage = "No Data Member Defined";
var viewData = new List <List <object> >();
if (State.ListSettings.Columns.Count == 0)
{
return(viewData);
}
if (State.ListSettings.Columns.Any(c => String.IsNullOrEmpty(c.DataMember)))
{
return(viewData);
}
object[,] dataValues = new object[GridRows.Count, State.ListSettings.Columns.Count];
Type rootObjectType = null;
object rootObjectValue = null;
for (int i = 0; i < State.ListSettings.Columns.Count; i++)
{
var column = State.ListSettings.Columns.FirstOrDefault(c => c.Index == i);
if (!String.IsNullOrEmpty(column.DataMember))
{
var dataFullPath = column.DataFullPath;
var dataPathSections = dataFullPath.Split('\\');
if (rootObjectType == null || rootObjectType.FullName != column.DataFeedFullName)
{
if (column.DataFeed == "LiveFeedData")
{
rootObjectType = LiveFeedData.GetType();
rootObjectValue = LiveFeedData;
}
else if (column.DataFeed == "LiveFlagData")
{
rootObjectType = LiveFlagData.GetType();
rootObjectValue = LiveFlagData;
}
else if (column.DataFeed == "LivePitData")
{
rootObjectType = LivePitData.GetType();
rootObjectValue = LivePitData;
}
else if (column.DataFeed == "LivePointsData")
{
rootObjectType = LivePointsData.GetType();
rootObjectValue = LivePointsData;
}
else if (column.DataFeed == "LiveQualifyingData")
{
rootObjectType = LiveQualifyingData.GetType();
rootObjectValue = LiveQualifyingData;
}
}
string listPropertyName = String.Empty;
string lengthPropertyName = String.Empty;
object listValue = null;
string[] dataPathSectionsFromList = null;
Type sectionType = null;
object sectionObject = null;
if (rootObjectType.Name == "List`1")
{
listValue = rootObjectValue;
lengthPropertyName = "Count";
}
else if (rootObjectType.IsArray)
{
listValue = rootObjectValue;
lengthPropertyName = "Length";
}
else
{
PropertyInfo listPropertyInfo = null;
lengthPropertyName = "Count";
sectionType = rootObjectType;
sectionObject = rootObjectValue;
int listSectionIndex = -1;
for (int a = 0; a < dataPathSections.Length; a++)
{
if (dataPathSections[a].Contains("[]"))
{
listSectionIndex = a;
listPropertyName = dataPathSections[a].Replace("[]", "");
listPropertyInfo = sectionType.GetProperty(listPropertyName);
listValue = listPropertyInfo.GetValue(sectionObject);
break;
}
}
int sectionsFromListCount = dataPathSections.Length - listSectionIndex - 1;
dataPathSectionsFromList = new string[sectionsFromListCount];
Array.Copy(dataPathSections, listSectionIndex + 1, dataPathSectionsFromList, 0, sectionsFromListCount);
}
int maxRows;
if (listValue != null)
{
String indexerName = ((DefaultMemberAttribute)listValue.GetType()
.GetCustomAttributes(typeof(DefaultMemberAttribute),
true)[0]).MemberName;
PropertyInfo indexerPropertyInfo = listValue.GetType().GetProperty(indexerName);
PropertyInfo lengthPropertyInfo = listValue.GetType().GetProperty(lengthPropertyName);
int listItemCount = (int)lengthPropertyInfo.GetValue(listValue);
maxRows = State.ListSettings.MaxRows.HasValue ?
State.ListSettings.MaxRows.Value <= listItemCount ?
State.ListSettings.MaxRows.Value :
listItemCount :
listItemCount;
maxRows = maxRows > GridRows.Count ? GridRows.Count : maxRows;
for (int r = 0; r < maxRows; r++)
{
Object listItemValue = indexerPropertyInfo.GetValue(listValue, new Object[] { r });
PropertyInfo sectionProperty = null;
object sectionValue = null;
sectionObject = listItemValue;
sectionType = sectionObject.GetType();
for (int x = 0; x < dataPathSectionsFromList.Length; x++)
{
sectionProperty = sectionType.GetProperty(dataPathSectionsFromList[x]);
sectionValue = sectionProperty.GetValue(sectionObject);
sectionType = sectionValue.GetType();
sectionObject = sectionValue;
}
dataValues[r, i] = sectionValue;
}
}
else
{
// Property on the root object (ex LiveFeedData.LapNumber)
// All rows get the same value.
maxRows = State.ListSettings.MaxRows.HasValue ?
State.ListSettings.MaxRows.Value :
GridRows.Count;
maxRows = maxRows > GridRows.Count ? GridRows.Count : maxRows;
PropertyInfo sectionProperty = sectionType.GetProperty(dataPathSectionsFromList[0]);
object sectionValue = sectionProperty.GetValue(sectionObject);
for (int r = 0; r < maxRows; r++)
{
dataValues[r, i] = sectionValue;
}
}
}
else
{
var maxRows = State.ListSettings.MaxRows.HasValue ?
State.ListSettings.MaxRows.Value <= GridRows.Count ?
State.ListSettings.MaxRows.Value :
GridRows.Count :
GridRows.Count;
for (int r = 0; r < maxRows; r++)
{
dataValues[r, i] = dataColumnErrorMessage;
}
}
}
var sortColumn = State.ListSettings.OrderedColumns.FirstOrDefault(c => c.SortType != Models.SortType.None);
object[,] sortedDataRows = sortColumn == null ?
dataValues :
sortColumn.SortType == Models.SortType.Ascending ?
dataValues.OrderBy(x => x[sortColumn.Index]) :
dataValues.OrderByDescending(x => x[sortColumn.Index]);
for (int g = 0; g < sortedDataRows.GetLength(0); g++)
{
List <object> viewRowData = new List <object>();
for (int h = 0; h < sortedDataRows.GetLength(1); h++)
{
viewRowData.Add(sortedDataRows[g, h]);
}
viewData.Add(viewRowData);
}
return(viewData);
}
