public void GetResult_Returns_Righ_Result_With_Leavers()
{
var laps = new List <Lap>
{
new Lap("12:01:12", "1", "testPosition2", "1", "1:11.111", "1"),
new Lap("12:01:12", "1", "testPosition2", "2", "1:11.111", "1"),
new Lap("12:01:12", "1", "testPosition2", "3", "1:11.111", "1"),
new Lap("12:01:12", "1", "testPosition2", "4", "1:11.111", "1"),
new Lap("12:01:12", "2", "testPosition1", "1", "0:11.111", "1"),
new Lap("12:01:12", "2", "testPosition1", "2", "0:11.111", "1"),
new Lap("12:01:12", "2", "testPosition1", "3", "0:11.111", "1"),
new Lap("12:01:12", "2", "testPosition1", "4", "0:11.111", "1"),
new Lap("12:01:12", "3", "testPosition3", "4", "0:11.111", "1")
};
var race = new Race(laps);
var raceResult = new RaceResult(race);
raceResult.GetResult();
raceResult.Result[0].Should().NotBeNull();
raceResult.Result[1].Should().NotBeNull();
raceResult.Result[0].Racer.Name.Should().Be("testPosition1");
raceResult.Result[0].Racer.RacerId.Should().Be(2);
raceResult.Result[1].Racer.Name.Should().Be("testPosition2");
raceResult.Result[1].Racer.RacerId.Should().Be(1);
raceResult.Leavers.Should().NotBeEmpty();
raceResult.Leavers[0].Racer.RacerId.Should().Be(3);
raceResult.Leavers[0].Racer.Name.Should().Be("testPosition3");
}
private async Task <bool> AddRaceResultWherePreviousExists(RaceResultViewModel model,
ICollection <RaceResult> RaceResults,
IQueryable <Member> members)
{
bool isSaveSuccess = true;
List <RaceResult> assignedRaceResults = new List <RaceResult>();
foreach (var recordId in model.MemberIds)
{
var currentMember = members.Where(a => a.Id == recordId).FirstOrDefault();
if (currentMember != null)
{
if (!RaceResults.Any(a => a.MemberId == recordId))
{
int ageGroupId = await CalculateAge(currentMember, model.RaceDistanceId);
var raceResultRepo = new RaceResult();
assignedRaceResults.Add(raceResultRepo.ToEntity(recordId, model.RaceDistanceId, model.TimeTaken, model.Position, ageGroupId, model.SessionUserId));
}
}
}
if (assignedRaceResults.Count > 0)
{
await _context.RaceResult.AddRangeAsync(assignedRaceResults);
await _context.SaveChangesAsync();
isSaveSuccess = true;
}
return(isSaveSuccess);
}
void Start()
{
gameMaster.OnLapChange += (newLap) => lap = newLap;
gameMaster.OnBestLap += (bestLap) => {
this.bestLap = TimeSpan.FromSeconds(bestLap);
bestTimeHighlight = 1;
};
gameMaster.OnRaceFinishes += (result) => {
showRaceResult = true;
this.result = result;
};
hudRect = new Rect(Screen.width - 130, 10, 120, 85);
lapRect = new Rect(hudRect.x + 15, hudRect.y + 5, 80, 20);
bestLabelRect = new Rect(hudRect.x + 15, hudRect.y + 40, 80, 20);
bestTimeRect = new Rect(hudRect.x + 15, hudRect.y + 57, 80, 20);
resultRect = new Rect(Screen.width/2 - 50, 100, 100, 30);
hudStyle = new GUIStyle();
hudStyle.normal.background = createFlatTexture(new Color(0, 0, 0, 0.4f));
titleStyle = new GUIStyle();
titleStyle.normal.textColor = Color.white;
titleStyle.fontSize = 26;
titleStyle.font = font;
labelStyle = new GUIStyle(titleStyle);
labelStyle.normal.textColor = Color.gray;
labelStyle.fontSize = 14;
valueStyle = new GUIStyle(titleStyle);
valueStyle.fontSize = 16;
bestTimeStyle = new GUIStyle(valueStyle);
}
private async Task <bool> AddEntity(RaceResultViewModel model,
ICollection <RaceResult> containerEntityList,
IQueryable <Member> referralEntityList)
{
bool isSaveSuccess = true;
List <RaceResult> RaceResultList = new List <RaceResult>();
foreach (var record in model.MemberIds)
{
var currentReferralEntity = referralEntityList.Any(a => a.Id == record);
if (currentReferralEntity)
{
int ageGroupId = await CalculateAge(referralEntityList.FirstOrDefault(), model.RaceDistanceId);
RaceResult RaceResult = new RaceResult();
RaceResultList.Add(RaceResult.ToEntity(record, model.RaceDistanceId, model.TimeTaken, model.Position, ageGroupId, model.SessionUserId));
}
}
if (RaceResultList.Count > 0)
{
await _context.RaceResult.AddRangeAsync(RaceResultList);
await _context.SaveChangesAsync();
isSaveSuccess = true;
}
return(isSaveSuccess);
}
public async Task <RaceResult> AddRaceResult(RaceResult raceResult)
{
_dbContext.RaceResults.Add(raceResult);
await _dbContext.SaveChangesAsync();
return(raceResult);
}
private static Dictionary <RaceResult, ComparativePerformanceResult> GetXYResults(List <RaceResult> raceResults, Dictionary <string, double> genderHistorgram)
{
var xyResults = new Dictionary <RaceResult, ComparativePerformanceResult>();
foreach (var raceResult in raceResults)
{
var tempsPartiel1 = RaceResult.ParseAsTimeSpan(raceResult.temps_partiel_1);
var tempsPartiel2 = RaceResult.ParseAsTimeSpan(raceResult.temps_partiel_2);
if (genderHistorgram.ContainsKey(raceResult.age) &&
tempsPartiel1.HasValue &&
tempsPartiel2.HasValue)
{
var totalTime = raceResult.GetTotalTimeAsTimeSpan();
var ageAverageTimeInMilliseconds = genderHistorgram[raceResult.age];
var ageAverageTime = TimeSpan.FromMilliseconds(ageAverageTimeInMilliseconds);
var firstHalfVsTotalTimeSpeedRatio = tempsPartiel1.Value.TotalMilliseconds / totalTime.Value.TotalMilliseconds;
var ageComparativePerformanceRatio = totalTime.Value.TotalMilliseconds / ageAverageTime.TotalMilliseconds;
var xyResult = new ComparativePerformanceResult(ageComparativePerformanceRatio, firstHalfVsTotalTimeSpeedRatio);
xyResults.Add(raceResult, xyResult);
}
}
return(xyResults);
}
public async Task <RaceResult> Create(RaceResult newRaceResult)
{
Db.RaceResults.Add(newRaceResult);
await Db.SaveChangesAsync();
return(newRaceResult);
}
public int CreateRaceResult(RaceResult raceResult)
{
entities.RaceResults.Add(raceResult);
int created = entities.SaveChanges();
return(raceResult.RaceResultID);
}
public async Task <IHttpActionResult> PutRaceResult(int id, RaceResult raceResult)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != raceResult.Id)
{
return(BadRequest());
}
db.Entry(raceResult).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RaceResultExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Time")] RaceResult raceResult)
{
if (id != raceResult.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(raceResult);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RaceResultExists(raceResult.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(raceResult));
}
public InstanceResultViewModel(string instanceName, RaceResult result, RaceTime time, bool isPresented = false)
{
this.InstanceName = instanceName;
this.Result = result;
this.Time = time;
this.IsPresented = isPresented;
}
private void SendResultBtn_Clicked(object s, EventArgs e)
{
RaceResult raceresult = new RaceResult();
raceresult.Time = Clocktxt.Text;
raceresult.RaceId = Int32.Parse(PlayContext.MapID);
HttpClientHandler clientHandler = new HttpClientHandler();
clientHandler.ServerCertificateCustomValidationCallback = (sender, cert, chain, sslPolicyErrors) => { return(true); };
System.Net.ServicePointManager.ServerCertificateValidationCallback = (message, cert, chain, errors) => { return(true); };
HttpClient client = new HttpClient(clientHandler);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Tokens.UserToken);
Uri uri = new Uri("https://xamaracing.azurewebsites.net//v1/RaceResults");
var content = JsonConvert.SerializeObject(raceresult);
var data = new StringContent(content, Encoding.UTF8, "application/json");
var response = client.PostAsync(uri, data).Result;
var result = response.Content.ReadAsStringAsync().Result;
//Clocktxt.Text = "Clock";
SendResultBtn.IsEnabled = false;
Clock.Reset();
MapNametxt.Text = "Map name";
}
public static BindingList <RaceResult> LoadRaceResult(string path)
{
path = Path.Combine(path, "race.rc");
BindingList <RaceResult> ret = new BindingList <RaceResult>();
string[] lines = File.ReadAllLines(path);
for (int i = 0; i < lines.Length; i++)
{
string[] raceResult = lines[i].Split('\t');
string txtId = raceResult[0];
string txtPosition = raceResult[1];
string txtName = raceResult[2];
string txtBestTime = raceResult[3];
string txtRaceTime = raceResult[4];
string txtAverageSpeed = raceResult[5];
int id = int.Parse(txtId);
int position = int.Parse(txtPosition);
TimeSpan bestTime = TimeSpan.Parse(txtBestTime);
TimeSpan raceTime = TimeSpan.Parse(txtRaceTime);
double average = double.Parse(txtAverageSpeed);
RaceResult rr = Factory.Factory.CreateRaceResult(id, position, txtName, bestTime, raceTime, average);
ret.Add(rr);
}
return(ret);
}
public ViewResult Create(int RaceId = 1)
{
ViewData["Driver"] = new SelectList(repository.Drivers.ToList(), "DriverID", "Name");
ViewData["Race"] = new SelectList(repository.Races.ToList(), "RaceID", "RaceDescription");
RaceResult rr = new RaceResult();
rr.RaceID = RaceId;
return View("Edit", rr);
}
public ActionResult DeleteConfirmed(int id)
{
RaceResult raceresult = db.RaceResultSet.Find(id);
db.RaceResultSet.Remove(raceresult);
db.SaveChanges();
return(RedirectToAction("Index"));
}
private RaceResultDto MapRaceResult(RaceResult raceResult)
{
var position = raceResult.Position;
var constructor = raceResult.Constructor.Name;
var driverCode = raceResult.Driver.Code;
var status = raceResult.Status.ToString();
return(new RaceResultDto(driverCode, position, constructor, status));
}
public async Task <List <RaceData> > GetRaceData(int runnerid)
{
var racedata = new List <RaceData>();
//Get times by runner
var listoftimes = await TimeServices.GetListOfTimesbyRunnerId(runnerid);
//Creates list of dates
Dictionary <int, DateTime> eventdates = new Dictionary <int, DateTime>();
Dictionary <int, string> eventseason = new Dictionary <int, string>();
//Select times from a event
var practices = listoftimes.GroupBy(ev => new { ev.EventId }).Select(grp => grp.First()).ToList();
foreach (var practice in practices)
{
var tmpevent = await EventServices.GetEventById(practice.EventId.GetValueOrDefault());
//if event is not a race remove form the list of races
if (!tmpevent.IsRace)
{
listoftimes.RemoveAll(e => e.EventId == practice.EventId.GetValueOrDefault());
}
else
//if event is a race creates a dictionary with Key the event Id and content the race date to use later
{
eventdates.Add(tmpevent.Id, tmpevent.RaceDate);
eventseason.Add(tmpevent.Id, tmpevent.Season);
}
}
//Creates RaceData
//Group list of times by Season
var groupseason = eventseason.GroupBy(d => d.Value);
foreach (var group in groupseason)
{
var raceresults = new List <RaceResult>();
foreach (var id in group)
{
var racesplits = listoftimes.Where(e => e.EventId == id.Key).ToList();
var raceresult = new RaceResult {
Date = eventdates[id.Key], Time = racesplits.Last().Times.TotalMilliseconds,
Distance = racesplits.Last().Distance
};
raceresults.Add(raceresult);
}
var races = new RaceData {
Season = group.Key, RaceResults = raceresults
};
racedata.Add(races);
}
return(racedata);
}
private static void Main(string[] args)
{
#region DI
var collection = new ServiceCollection();
collection.AddSingleton <IFileReader, FileReader>();
collection.AddSingleton <IResultGenerator <Lap>, ResultGenerator>();
collection.AddSingleton <IRepository <Lap>, Repository <Lap> >();
collection.AddSingleton <IApplication, Application.Application>();
var serviceProvider = collection.BuildServiceProvider();
#endregion DI
var service = serviceProvider.GetService <IRepository <Lap> >();
var application = serviceProvider.GetService <IApplication>();
var race = new Race(service.GetAll());
var result = new RaceResult(race);
Console.WriteLine(application.GetInitialMenu());
var option = Console.ReadLine();
switch (option)
{
case "1":
result.GetResult();
var raceResult = application.GetFinalResult(result.Result, result.Leavers);
Console.WriteLine(raceResult);
break;
case "2":
var bestLap = race.GetBestLap();
Console.WriteLine(application.GetBestLap(bestLap));
break;
case "3":
var bestLaps = race.GetBestLapFromEachRacer();
Console.WriteLine(application.GetBestLapFromEachRacer(bestLaps));
break;
case "4":
var averageSpeed = result.GetAverageSpeed();
Console.WriteLine(application.GetAverageSpeedFromEachRacer(averageSpeed));
break;
case "5":
default:
var completedAfterFirst = result.GetCompletedTimeAfterFirst();
Console.WriteLine(application.GetCompletedTimeAfterFirst(completedAfterFirst));
break;
}
Console.ReadKey();
}
//
// GET: /RaceResult/Details/5
public ActionResult Details(int id = 0)
{
RaceResult raceresult = db.RaceResultSet.Find(id);
if (raceresult == null)
{
return(HttpNotFound());
}
return(View(raceresult));
}
public void OnPostSubmitRaceResult(RaceResult raceResult)
{
int raceId = int.Parse(HttpContext.GetRouteData().Values["id"].ToString());
raceResult.Approved = false;
raceResult.RaceRefId = raceId;
_raceResultRepository.AddRaceResult(raceResult);
ShowMessage = true;
}
public async Task <IHttpActionResult> Get([FromODataUri] int key)
{
RaceResult result = await ResultsService.Find(key);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
private List <RaceState> GenerateRaceStatesFor25FPS(RaceResult raceResult)
{
List <RaceState> raceStates;
raceStates = new List <RaceState>();
RaceState raceStateA;
RaceState raceStateB;
int raceStateIndex = 0;
double time = 0;
double stopTime = Math.Ceiling(raceResult.RaceStates.Last().Time);
int timeIndex = 0;
raceStateA = raceResult.RaceStates[0];
raceStateB = raceResult.RaceStates[1];
while (time < stopTime)
{
int frameIndex;
for (frameIndex = 0; frameIndex < 25; frameIndex++)
{
time = timeIndex + frameIndex / 25.0;
while (((raceStateIndex + 1) < raceResult.RaceStates.Count) && (time >= raceResult.RaceStates[raceStateIndex + 1].Time))
{
raceStateIndex++;
if (raceStateIndex < raceResult.RaceStates.Count)
{
raceStateA = raceStateB;
raceStateB = raceResult.RaceStates[raceStateIndex + 1];
}
}
RaceState raceStateForFrame;
//raceStateForFrame = raceResult.RaceStates[raceStateIndex].Copy();
//raceStateForFrame.Time = time;
raceStateForFrame = RaceState.CreateInterpolation(raceStateA, raceStateB, time);
//raceStateA = raceResult.RaceStates[raceStateIndex];
//raceStateB = raceResult.RaceStates[raceStateIndex + 1];
raceStates.Add(raceStateForFrame);
}
timeIndex++;
time = timeIndex;
}
return(raceStates);
}
public async Task <IHttpActionResult> GetRaceResult(int id)
{
RaceResult raceResult = await db.RaceResults.FindAsync(id);
if (raceResult == null)
{
return(NotFound());
}
return(Ok(raceResult));
}
public IActionResult Post([FromForm] IFormFile file)
{
RaceRequest requestRaceResult = new RaceRequest(file);
RaceResult <Metrics> raceResult = _raceUseCase.ProcessRaceResult(requestRaceResult);
var presenter = new RacePresenter();
presenter.Populate(raceResult);
return(presenter.ViewModel);
}
public async Task <IActionResult> Create([Bind("Id,Time")] RaceResult raceResult)
{
if (ModelState.IsValid)
{
_context.Add(raceResult);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(raceResult));
}
public static RaceResult CreateRaceResult(int ID, int raceId, int position, int racerId, int teamId)
{
RaceResult raceResult = new RaceResult();
raceResult.Id = ID;
raceResult.RaceId = raceId;
raceResult.Position = position;
raceResult.RacerId = racerId;
raceResult.TeamId = teamId;
return(raceResult);
}
public ActionResult Edit(RaceResult raceresult)
{
if (ModelState.IsValid)
{
db.Entry(raceresult).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.RaceId = new SelectList(db.RaceSet, "Id", "Pool", raceresult.RaceId);
ViewBag.BoatId = new SelectList(db.BoatSet, "Id", "Name", raceresult.BoatId);
return(View(raceresult));
}
public ActionResult Create([Bind(Include = "ID,NAME,TIME,MeetID,AthleteID")] RaceResult raceResult)
{
if (ModelState.IsValid)
{
db.RaceResults.Add(raceResult);
db.SaveChanges();
}
ViewBag.AthleteID = new SelectList(db.Athletes, "ID", "NAME", raceResult.AthleteID);
ViewBag.MeetID = new SelectList(db.Meets, "ID", "DATE", raceResult.MeetID);
return(View(raceResult));
}
//
// GET: /RaceResult/Edit/5
public ActionResult Edit(int id = 0)
{
RaceResult raceresult = db.RaceResultSet.Find(id);
if (raceresult == null)
{
return(HttpNotFound());
}
ViewBag.RaceId = new SelectList(db.RaceSet, "Id", "Pool", raceresult.RaceId);
ViewBag.BoatId = new SelectList(db.BoatSet, "Id", "Name", raceresult.BoatId);
return(View(raceresult));
}
public async Task <IHttpActionResult> PostRaceResult(RaceResult raceResult)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.RaceResults.Add(raceResult);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = raceResult.Id }, raceResult));
}
public void SaveRaceResult(RaceResult raceResult)
{
if (raceResult.RaceResultID == 0)
{
context.RaceResults.Add(raceResult);
}
else
{
context.Entry(raceResult).State = EntityState.Modified;
}
context.SaveChanges();
}
public ActionResult Edit(RaceResult raceResult)
{
if (ModelState.IsValid)
{
repository.SaveRaceResult(raceResult);
TempData["message"] = "RaceResult has been saved.";
return RedirectToRoute(new { controller = "Race", action = "Edit", id = raceResult.RaceID });
}
else
{
return Edit(raceResult.RaceResultID);
}
}
public override void FillEmptyControl()
{
try
{
BIZ.RaceResult raceResult = new RaceResult();
Common.Common.FillDropdownList(rcbBirdCategory, raceResult.GetBirdCategory(ClubID).Tables[0], "Description", "Description", true, "All");
Common.Common.FillDropdownList(rcbGroupCategory, raceResult.GetGroupCategory(ClubID).Tables[0], "RaceGroup", "RaceGroup", true, "All");
}
catch (Exception ex)
{
Common.Common.RaiseMessage(RadWindowManager1, ex.Message, "RaceResult", Page.ToString(), MethodBase.GetCurrentMethod().Name, "", "Mavcpigeonclocking");
}
}
private static List <RaceResult> ReadAllRacesToMemory(FileInfo[] files)
{
List <RaceResult> allRaceResults = new List <RaceResult>();
foreach (var file in files)
{
string json = File.ReadAllText(file.FullName);
RaceResult raceResult = JsonConvert.DeserializeObject <RaceResult>(json);
allRaceResults.Add(raceResult);
}
return(allRaceResults);
}
public ActionResult Delete(RaceResult raceResult)
{
if (ModelState.IsValid)
{
RaceResult rr = repository.RaceResults.FirstOrDefault(p => p.RaceResultID == raceResult.RaceResultID);
repository.DeleteRaceResult(rr);
return RedirectToRoute(new { controller = "Race", action = "Edit", id = rr.RaceID });
}
else
{
RaceResult rr = repository.RaceResults.FirstOrDefault(p => p.RaceResultID == raceResult.RaceResultID);
return View(rr);
}
}
public void DeleteRaceResult(RaceResult raceResult)
{
context.RaceResults.Remove(raceResult);
context.SaveChanges();
}
private IList<RaceResult> GetResultsFromWeb(int season, GrandPrix gp)
{
IList<RaceResult> results = new List<RaceResult>();
Uri url = new Uri("http://www.formula1.com/results/season/" + season.ToString(CultureInfo.GetCultureInfo("en-US")) + "/" + gp.WebId + "/");
HtmlReader reader = new HtmlReader();
string html = reader.GetHtmlFromUrl(url);
Collection<object[]> resultsRead = F1HtmlParserHelper.ParseRaceResultHtml(html);
var carRepo = this.container.Resolve<IVehicleRepository>();
TimeSpan pos1Time = new TimeSpan();
foreach (var item in resultsRead)
{
// Vehicle car = carRepo.GetByDriverName((string)item[2]);
Vehicle car = carRepo.GetByCarNo(Convert.ToInt32((byte)item[1]));
RaceResult rr = new RaceResult()
{
GrandPrix = gp,
Position = Convert.ToInt32((byte)item[0], CultureInfo.GetCultureInfo("en-US")),
Vehicle = car,
LapsNo = Convert.ToInt32((byte)item[4], CultureInfo.GetCultureInfo("en-US")),
Time = pos1Time.Add((TimeSpan)item[5]),
Description = (string)item[6]
};
if (((TimeSpan)item[5]).TotalMilliseconds == 0d)
{
rr.Time = TimeSpan.FromMilliseconds(-1);
}
if (rr.Position == 1)
{
pos1Time = rr.Time;
}
results.Add(rr);
}
return results;
}
/// <summary>
/// Calculates the car time.
/// </summary>
/// <param name="car">The car to calculate time.</param>
/// <param name="grandPrixResult">The grand prix result.</param>
/// <returns>A partially complete race result.</returns>
public RaceResult CalculateCarTime(Vehicle car, IList<RaceResult> grandPrixResult)
{
if (car == null)
{
throw new ArgumentNullException("car");
}
if (grandPrixResult == null)
{
throw new ArgumentNullException("grandPrixResult");
}
if (grandPrixResult.Count == 0)
{
throw new ArgumentException("List is empty.", "grandPrixResult");
}
if (car.Team == null)
{
throw new ArgumentException("Car has no team.", "car");
}
if (!car.Team.IsPlayable)
{
throw new InvalidOperationException("Car is not playable.");
}
RaceResult result = new RaceResult() { Vehicle = car, GrandPrix = grandPrixResult[0].GrandPrix, LapsNo = grandPrixResult[0].LapsNo };
if (!this.CheckVehicleToRace(car))
{
result.Time = TimeSpan.FromMilliseconds(-1); // Not ready to start the race
result.Description = "Not ready to start the race";
}
else
{
var vehRepo = this.container.Resolve<IVehicleRepository>();
RaceResult lastWithTime = this.GetTheLastWithTime(grandPrixResult);
Dictionary<string, double> percents = this.BuildPercentComponentsMap();
IncidentProbabilityHelper probHelper = new IncidentProbabilityHelper(grandPrixResult);
probHelper.RegisterIncidentPerDriver(car.Driver);
if (probHelper.DecideIfThereIsAnIncident("Driver"))
{
result.Time = TimeSpan.FromMilliseconds(-1);
result.Description = "Accident";
}
else
{
RaceResult driverResult = grandPrixResult.Where(x => x.Vehicle.Driver.Equals(car.Driver) && x.Time > TimeSpan.FromMilliseconds(0)).FirstOrDefault();
if (driverResult == null)
{
// Driver with less laps... get the time of the last with a time
driverResult = lastWithTime;
}
double driverMillisecs = driverResult.Time.TotalMilliseconds * percents["Driver"];
result.Time = result.Time.Add(TimeSpan.FromMilliseconds(driverMillisecs));
foreach (var part in car.WearingParts)
{
IList<Vehicle> vehs = vehRepo.GetVehiclesWearingADesign(this.GetBaseDesign(part.Design));
probHelper.RegisterIncidentsPerDesign(part.Design, vehs);
if (probHelper.DecideIfThereIsAnIncident(part.Design.PartDesignType.Name))
{
result.Time = TimeSpan.FromMilliseconds(-1);
result.Description = part.Design.PartDesignType.Name;
break;
}
else
{
double millisecs = 0;
int count = 0;
foreach (var v in vehs)
{
RaceResult r = grandPrixResult.Where(x => x.Vehicle.Id == v.Id && x.Time > TimeSpan.FromMilliseconds(0)).FirstOrDefault();
if (r != null)
{
millisecs += r.Time.TotalMilliseconds * percents[part.Design.PartDesignType.Name];
count++;
}
}
if (count > 0)
{
millisecs = millisecs / count;
}
else
{
// No reference time to make the calculation
// Get the last driver with a time, and make the calculation on it
millisecs = lastWithTime.Time.TotalMilliseconds * percents[part.Design.PartDesignType.Name];
}
result.Time = result.Time.Add(TimeSpan.FromMilliseconds(millisecs));
}
}
}
}
if (result.Time < TimeSpan.FromMilliseconds(0))
{
result.LapsNo = 0;
}
return result;
}
