public RiderGCResults(string nNameofGCRace, string nNameofTeam, string nPosition, date nDate, int nNumberofStages)
{
this.NameofGCRace = nNameofGCRace;
this.Team = nNameofTeam;
this.Position = nPosition;
this.DateofGC = nDate;
this.Numberofstages = nNumberofStages;
}
public RiderResults(string nNameofTeam, string nNameofRace, string nPosition, date ndate, float nRaceLength, int nRacedifficulty, string nRaceType, int nCobbledifficulty, float nClimbDifficultyNormalised, float nLengthDifficultyNormalized)
{
this.Team = nNameofTeam;
this.Nameofrace = nNameofRace;
this.Position = nPosition;
this.Dateofresult = ndate;
this.Racelength = nRaceLength;
this.Racedifficulty = nRacedifficulty;
this.Racetype = nRaceType;
this.Cobbledifficulty = nCobbledifficulty;
this.Climbdifficultynormalized = nClimbDifficultyNormalised;
this.Lengthdifficulty = nLengthDifficultyNormalized;
}
public stages(string nRacename, string nRaceStatus, string nRacetype, int nYearEdition, List <TTTformat> nTTTresults, date nDate)
{
this.Racename = nRacename;
this.Racestatus = nRaceStatus;
this.Racetype = nRacetype;
this.Yearedition = nYearEdition;
this.TTTResults = nTTTresults;
this.Dates = nDate;
}
public stages(string nRacename, string nRacestatus, string nRacetype, int nYearedition, List <raceresults> nResults, date nDate, float nRacelength, int nRacedifficulty, int nCobbledifficulty)
{
this.Racename = nRacename;
this.Racestatus = nRacestatus;
this.Racetype = nRacetype;
this.Yearedition = nYearedition;
this.Results = nResults;
this.Dates = nDate;
this.Racelength = nRacelength;
this.Racedifficulty = nRacedifficulty;
this.Cobbledifficulty = nCobbledifficulty;
}
//This matches the race results to a property of the riders called RaceResult. This saves time in the future and stops having to do a search algorithm everytime you want to search for a result.
public static void resultsmatcher()
{
foreach (var stages in Singleton_Class.ListofStageRaces)
{
for (int x = 0; x < stages.Stageresults.Count; x++)
{
for (int y = 0; y < stages.Stageresults[x].Results.Count; y++)
{
if (stages.Stageresults[x].Results[y].Position.Equals(""))
{
stages.Stageresults[x].Results[y].Position = "DNS";
}
}
}
}
foreach (var stages in Singleton_Class.ListofPCTStageRaces)
{
for (int x = 0; x < stages.Stageresults.Count; x++)
{
for (int y = 0; y < stages.Stageresults[x].Results.Count; y++)
{
if (stages.Stageresults[x].Results[y].Position.Equals(""))
{
stages.Stageresults[x].Results[y].Position = "DNS";
}
}
}
}
foreach (var stages in Singleton_Class.ListofStageRaces)
{
stages.timecorrector(Singleton_Class.ListofStageRaces);
stages.timecorrector(Singleton_Class.ListofPCTStageRaces);
break;
}
foreach (var stages in Singleton_Class.ListofStageRaces)
{
stages.GCRiderCounter(Singleton_Class.ListofStageRaces);
break;
}
foreach (var stages in Singleton_Class.ListofStageRaces)
{
for (int x = 0; x < stages.Stageresults.Count; x++)
{
if (stages.Stageresults[x].Racename.Contains("France") && stages.Stageresults[x].Yearedition == 2019 && x == 18)
{
for (int y = 0; y < stages.Stageresults[x].Results.Count; y++)
{
stages.Stageresults[x].Results[y].Position = (y + 1).ToString();
}
}
}
}
foreach (var rider in Singleton_Class.ListofRiders)
{
List <RiderResults> ResultsofRider = new List <RiderResults>();
List <RiderResults> RiderStageRaceResults = new List <RiderResults>();
List <RiderGCResults> RiderGCResultsList = new List <RiderGCResults>();
List <RiderResults> PCTOneDayResults = new List <RiderResults>();
List <RiderResults> PCTStageRaceStageResults = new List <RiderResults>();
List <RiderGCResults> PCTStageRaceGCResults = new List <RiderGCResults>();
string name = rider.Fullname.ToLower().Trim();
foreach (var race in Singleton_Class.ListofWTOneDayRaces)
{
for (int x = 0; x < race.Results.Count; x++)
{
string ridermatcher = race.Results[x].Riderinrace.ToLower().Trim();
if (ridermatcher.Equals(name))
{
string position = race.Results[x].Position;
string team = race.Results[x].Team;
date date = race.Dates;
string racename = race.Racename;
float racelength = race.Racelength;
int difficulty = race.Racedifficulty;
string type = race.Racetype;
int cobbled = race.Cobbledifficulty;
float normalizedlength = race.Lengthdifficulty;
float normalizedclimb = race.Climbdifficultynormalized;
RiderResults searchedresults = new RiderResults(team, racename, position, date, racelength, difficulty, type, cobbled, normalizedclimb, normalizedlength);
ResultsofRider.Add(searchedresults);
}
}
}
rider.Riderresult = ResultsofRider;
foreach (var stagerace in Singleton_Class.ListofStageRaces)
{
for (int y = 0; y < stagerace.Stageresults.Count; y++)
{
for (int z = 0; z < stagerace.Stageresults[y].Results.Count; z++)
{
string ridermatch = stagerace.Stageresults[y].Results[z].Riderinrace.ToLower().Trim();
if (ridermatch.Equals(name))
{
string position = stagerace.Stageresults[y].Results[z].Position;
string team = stagerace.Stageresults[y].Results[z].Team;
date date = stagerace.Stageresults[y].Dates;
string racename = stagerace.Stageresults[y].Racename;
float racelength = stagerace.Stageresults[y].Racelength;
int difficulty = stagerace.Stageresults[y].Racedifficulty;
string type = stagerace.Stageresults[y].Racetype;
int cobbled = stagerace.Stageresults[y].Cobbledifficulty;
float normalizedlength = stagerace.Stageresults[y].Lengthdifficulty;
float normalizedclimb = stagerace.Stageresults[y].Climbdifficultynormalized;
RiderResults stageresults = new RiderResults(team, racename, position, date, racelength, difficulty, type, cobbled, normalizedclimb, normalizedlength);
RiderStageRaceResults.Add(stageresults);
}
}
}
}
rider.RiderStageRaceResult = RiderStageRaceResults;
foreach (var stagerace in Singleton_Class.ListofStageRaces)
{
for (int x = 0; x < stagerace.Gcclassification.GcResults.Count; x++)
{
string riderGCMatch = stagerace.Gcclassification.GcResults[x].Riderinrace.ToLower().Trim();
if (riderGCMatch.Equals(name))
{
string position = stagerace.Gcclassification.GcResults[x].Position;
string team = stagerace.Gcclassification.GcResults[x].Team;
string nameofGCrace = stagerace.Stageresults[0].Racename + " " + stagerace.Stageresults[0].Yearedition;
string formattedGCname = nameofGCrace.Replace("stage-1", "General-Classification");
date DateofGC = stagerace.Stageresults[0].Dates;
int numberofstages = stagerace.Stageresults.Count;
RiderGCResults GCresults = new RiderGCResults(formattedGCname, team, position, DateofGC, numberofstages);
RiderGCResultsList.Add(GCresults);
}
}
}
foreach (var PCTOneDayRace in Singleton_Class.ListofPCTOneDayRaces)
{
for (int x = 0; x < PCTOneDayRace.Results.Count; x++)
{
string ridermatcher = PCTOneDayRace.Results[x].Riderinrace.ToLower().Trim();
if (ridermatcher.Equals(name))
{
string position = PCTOneDayRace.Results[x].Position;
string team = PCTOneDayRace.Results[x].Position;
date date = PCTOneDayRace.Dates;
string racename = PCTOneDayRace.Racename;
float racelength = PCTOneDayRace.Racelength;
int difficulty = PCTOneDayRace.Racedifficulty;
string type = PCTOneDayRace.Racetype;
int cobbled = PCTOneDayRace.Cobbledifficulty;
float normalizedlength = PCTOneDayRace.Lengthdifficulty;
float normalizedclimb = PCTOneDayRace.Climbdifficultynormalized;
RiderResults searchedresults = new RiderResults(team, racename, position, date, racelength, difficulty, type, cobbled, normalizedclimb, normalizedlength);
PCTOneDayResults.Add(searchedresults);
}
}
}
rider.PCTOneDayRaceResults = PCTOneDayResults;
foreach (var PCTStage in Singleton_Class.ListofPCTStageRaces)
{
for (int x = 0; x < PCTStage.Stageresults.Count; x++)
{
for (int y = 0; y < PCTStage.Stageresults[x].Results.Count; y++)
{
string ridermatcher = PCTStage.Stageresults[x].Results[y].Riderinrace.ToLower().Trim();
if (ridermatcher.Equals(name))
{
string position = PCTStage.Stageresults[x].Results[y].Position;
string team = PCTStage.Stageresults[x].Results[y].Team;
date date = PCTStage.Stageresults[x].Dates;
string racename = PCTStage.Stageresults[x].Racename;
float racelength = PCTStage.Stageresults[x].Racelength;
int difficulty = PCTStage.Stageresults[x].Racedifficulty;
string type = PCTStage.Stageresults[x].Racetype;
int cobbled = PCTStage.Stageresults[x].Cobbledifficulty;
float normalizedlength = PCTStage.Stageresults[x].Lengthdifficulty;
float normalizedclimb = PCTStage.Stageresults[x].Climbdifficultynormalized;
RiderResults StageResults = new RiderResults(team, racename, position, date, racelength, difficulty, type, cobbled,
normalizedclimb, normalizedclimb);
PCTStageRaceStageResults.Add(StageResults);
}
}
}
}
rider.PCTStageRaceStageResults = PCTStageRaceStageResults;
foreach (var PCTGC in Singleton_Class.ListofPCTStageRaces)
{
for (int x = 0; x < PCTGC.Gcclassification.GcResults.Count; x++)
{
string riderGCmatch = PCTGC.Gcclassification.GcResults[x].Riderinrace.ToLower().Trim();
if (riderGCmatch.Equals(name))
{
string position = PCTGC.Gcclassification.GcResults[x].Position;
string team = PCTGC.Gcclassification.GcResults[x].Team;
string formattedGCname;
date DateofGC = new date();
try
{
string nameofGCRace = PCTGC.Stageresults[0].Racename + " " + PCTGC.Stageresults[0].Yearedition;
formattedGCname = nameofGCRace.Replace("stage-1", "General-Classification");
}
catch (Exception NameError)
{
formattedGCname = "Name Error";
}
try
{
DateofGC = PCTGC.Stageresults[0].Dates;
}
catch (Exception Datesexception)
{
DateofGC.Day = 1;
DateofGC.Month = 1;
DateofGC.Year = 2011;
}
int numberofstage = PCTGC.Stageresults.Count;
RiderGCResults ResultsOfPCTGC = new RiderGCResults(formattedGCname, team, position, DateofGC, numberofstage);
RiderGCResultsList.Add(ResultsOfPCTGC);
}
}
}
rider.RiderGC = RiderGCResultsList;
}
foreach (var rider in Singleton_Class.ListofRiders)
{
rider.StandardDeviationOfMountainStages(Singleton_Class.ListofRiders);
break;
}
TeamMatcher();
}
public static async void ContiOneDayRaceDownloader()
{
bool filechecker = false;
if (File.Exists(@"C:\Users\Wenqing Huang\c#\CTOneDayRaces.xml"))
{
filechecker = true;
}
while (filechecker == false)
{
var _RacesInDocument = await HTTPDownloader("https://www.procyclingstats.com/races.php?name=&pname=contains&nation=&class=1.1&category=1&filter=Filter&s=races-database");
var _ListOfCTRaces = DocumentScraperNode("table", "class", "basic", _RacesInDocument);
var _CTRaceNameList = DocumentScraperIndex("a", "href", "race", _ListOfCTRaces, 0);
int counter = 0;
string[] CTOneDayRaceNames = new string[_CTRaceNameList.Count];
string[] CTOneDayRaceStatus = new string[_CTRaceNameList.Count];
foreach (var race in _CTRaceNameList)
{
CTOneDayRaceNames[counter] = race.InnerText.ToString();
CTOneDayRaceStatus[counter] = "1.1";
counter = counter + 1;
}
var DocumentURL = _ListOfCTRaces[0].InnerHtml.ToString();
var reg = new Regex("\".*?\"");
List <string> URLsOfRaces = new List <String>();
var matches = reg.Matches(DocumentURL);
foreach (var match in matches)
{
if (match.ToString().Contains("race"))
{
string url = match.ToString().Split(new string[] { "race/", "/2" }, 3, StringSplitOptions.None)[1];
URLsOfRaces.Add(url);
}
}
for (int RaceURLIterator = 0; RaceURLIterator < URLsOfRaces.Count; RaceURLIterator++)
{
for (int year = 2011; year < 2021; year++)
{
string race = URLsOfRaces[RaceURLIterator];
var RaceInDocument = await HTTPDownloader("https://www.procyclingstats.com/race/" + race + "/" + year);
var RaceInDocumentOverview = await HTTPDownloader("https://www.procyclingstats.com/race/" + race + "/" + year + "/" + "overview");
List <HtmlNode> CTOneDayRaceDateSection;
List <HtmlNode> CTOneDayLengthInitial;
List <HtmlNode> CTOneDayLengthParsed;
string CTLengthOfRace;
try
{
CTOneDayRaceDateSection = DocumentScraperNode("ul", "class", "infolist fs13", RaceInDocumentOverview);
CTOneDayLengthInitial = DocumentScraperNode("div", "class", "sub", RaceInDocumentOverview);
CTOneDayLengthParsed = DocumentScraperIndex("span", "class", "red fw400", CTOneDayLengthInitial, 0);
}
catch (Exception e)
{
continue;
}
float _CTLengthofRace;
try
{
CTLengthOfRace = Regex.Replace(CTOneDayLengthParsed[0].InnerText.ToString(), @"[^0-9\.]", "");
_CTLengthofRace = float.Parse(CTLengthOfRace);
}
catch (Exception e)
{
continue;
}
string DateFormatter = CTOneDayRaceDateSection[0].InnerText.ToString().Split(new string[] { "Startdate:", "\n" }, 3, StringSplitOptions.None)[1];
int DayOfRace = int.Parse(DateFormatter.Substring(9, 2));
int MonthOfRace = int.Parse(DateFormatter.Substring(6, 2));
date racedate = new date();
racedate.Day = DayOfRace;
racedate.Month = MonthOfRace;
racedate.Year = year;
var CTOneDayRacesParsed = DocumentScraperNode("table", "class", "basic results", RaceInDocument);
List <HtmlNode> CTOneDayRacesRiders;
try
{
CTOneDayRacesRiders = DocumentScraperIndex("a", "href", "rider", CTOneDayRacesParsed, 0);
}
catch (Exception e)
{
continue;
}
var CTOneDayRaceResultsRankings = DocumentScraperIndex("tr", "data-id", "", CTOneDayRacesParsed, 0);
string[] PlaceHolderRankings = new string[CTOneDayRaceResultsRankings.Count - 1];
string[] ParsedRankings = new string[CTOneDayRaceResultsRankings.Count - 1];
for (int FirstRankingLoop = 1; FirstRankingLoop < CTOneDayRaceResultsRankings.Count; FirstRankingLoop++)
{
PlaceHolderRankings[FirstRankingLoop - 1] = CTOneDayRaceResultsRankings[FirstRankingLoop].InnerHtml;
}
for (int SecondRankingLoop = 0; SecondRankingLoop < PlaceHolderRankings.Length; SecondRankingLoop++)
{
string RankingParsed = PlaceHolderRankings[SecondRankingLoop].Substring(0, 7);
string result = "";
for (int RankingThirdLoop = 0; RankingThirdLoop < 7; RankingThirdLoop++)
{
if (char.IsDigit(RankingParsed[RankingThirdLoop]))
{
result = result + RankingParsed[RankingThirdLoop];
}
}
ParsedRankings[SecondRankingLoop] = CheckForNoneFinish(result);
}
string[] ParsedCTOneDayRiderNames = new string[CTOneDayRacesRiders.Count];
for (int i = 0; i < CTOneDayRacesRiders.Count; i++)
{
ParsedCTOneDayRiderNames[i] = CTOneDayRacesRiders[i].InnerText.ToString();
}
var ParsedCTOneDayRaceTime = DocumentScraperEquals("td", "class", "time ar", CTOneDayRacesParsed, 0);
var CTOneDayRaceTeam = DocumentScraperIndex("td", "class", "cu600", CTOneDayRacesParsed, 0);
string[] CTOneDayRaceTimes = new string[ParsedCTOneDayRiderNames.Length];
string[] PositionInRace = new string[ParsedCTOneDayRiderNames.Length];
string[] TeamOfRider = new string[ParsedCTOneDayRiderNames.Length];
for (int j = 0; j < ParsedCTOneDayRiderNames.Length; j++)
{
if (j != 0)
{
string ParseTime = ParsedCTOneDayRaceTime[j].InnerHtml.ToString();
string Parsed = ParseTime.Split(new string[] { "<td class=\"time ar\"><span>", "</span>" }, 2, StringSplitOptions.None)[0];
string FinalTimeParse = Parsed.Replace("<span>", "");
CTOneDayRaceTimes[j] = FinalTimeParse;
}
else
{
CTOneDayRaceTimes[j] = ParsedCTOneDayRaceTime[j].InnerText.ToString();
}
PositionInRace[j] = ParsedRankings[j];
TeamOfRider[j] = CTOneDayRaceTeam[j].InnerText.ToString();
}
List <raceresults> ResultsOfCTRace = new List <raceresults>();
for (int k = 0; k < ParsedCTOneDayRiderNames.Length; k++)
{
ResultsOfCTRace.Add(new raceresults(PositionInRace[k], ParsedCTOneDayRiderNames[k], CTOneDayRaceTimes[k], TeamOfRider[k]));
}
var ClimbingDifficultyScraped = DocumentScraperNode("ul", "class", "infolist", RaceInDocument);
string DifficultyExtractor = ClimbingDifficultyScraped[0].InnerHtml.ToString().Split(new string[] { "<li><div>ProfileScore: </div> <div>" }, 2, StringSplitOptions.None)[1]
.Split(new string[] { "</div>" }, 2, StringSplitOptions.None)[0];
int IntegerDifficulty;
try
{
IntegerDifficulty = int.Parse(DifficultyExtractor);
}
catch (Exception x)
{
IntegerDifficulty = 0;
}
int CobbledDifficulty = 0;
string RaceType = RaceTypeCalculator(IntegerDifficulty);
Singleton_Class.ListofCTOneDayRaces.Add(new Races(race, CTOneDayRaceStatus[1], RaceType, year, ResultsOfCTRace, racedate, _CTLengthofRace, IntegerDifficulty, CobbledDifficulty));
}
}
Console.WriteLine("Test");
Console.ReadLine();
float MaxLength = Singleton_Class.ListofCTOneDayRaces[0].Racelength;
float MinLength = Singleton_Class.ListofCTOneDayRaces[0].Racelength;
for (int maxminchecker = 0; maxminchecker < Singleton_Class.ListofCTOneDayRaces.Count(); maxminchecker++)
{
if (Singleton_Class.ListofCTOneDayRaces[maxminchecker].Racelength > MaxLength)
{
MaxLength = Singleton_Class.ListofCTOneDayRaces[maxminchecker].Racelength;
}
if (Singleton_Class.ListofCTOneDayRaces[maxminchecker].Racelength < MinLength)
{
MinLength = Singleton_Class.ListofCTOneDayRaces[maxminchecker].Racelength;
}
}
float MaxDifficulty = Singleton_Class.ListofCTOneDayRaces[0].Racedifficulty;
float MinDifficulty = Singleton_Class.ListofCTOneDayRaces[0].Racedifficulty;
for (int difficultychecker = 0; difficultychecker < Singleton_Class.ListofCTOneDayRaces.Count(); difficultychecker++)
{
if (Singleton_Class.ListofCTOneDayRaces[difficultychecker].Racedifficulty > MaxDifficulty)
{
MaxDifficulty = Singleton_Class.ListofCTOneDayRaces[difficultychecker].Racedifficulty;
}
if (Singleton_Class.ListofCTOneDayRaces[difficultychecker].Racedifficulty < MinDifficulty)
{
MinDifficulty = Singleton_Class.ListofCTOneDayRaces[difficultychecker].Racedifficulty;
}
}
foreach (var race in Singleton_Class.ListofCTOneDayRaces)
{
float RaceLengthDifficulty = race.Racelength;
race.Lengthdifficulty = RaceLengthNormalized(RaceLengthDifficulty, MaxLength, MinLength);
float NormalizedClimbDifficulty = race.Racedifficulty;
race.Climbdifficultynormalized = RaceDifficultyNormalized(NormalizedClimbDifficulty, MaxDifficulty, MinDifficulty);
}
using (TextWriter CTOneDayTextWriter = new StreamWriter(@"C:\Users\Wenqing Huang\c#\CTOneDayRaces.xml"))
{
XmlSerializer CTOneDaySerializer = new XmlSerializer(typeof(List <Races>));
CTOneDaySerializer.Serialize(CTOneDayTextWriter, Singleton_Class.ListofCTOneDayRaces);
}
filechecker = true;
}
if (filechecker == true)
{
XmlSerializer CTOneDayLoader = new XmlSerializer(typeof(List <Races>));
using (FileStream CTLoader = File.OpenRead(@"C:\Users\Wenqing Huang\c#\CTOneDayRaces.xml"))
{
Singleton_Class.ListofCTOneDayRaces = (List <Races>)CTOneDayLoader.Deserialize(CTLoader);
}
}
DictionaryResultsMatcher.resultsmatcher();
}
