public void WebScrapperToDb2016_2017()
{
//TODONEW: Probar a instalar y ejecutar el proyecto desde cero.
//TODONEW: Eliminar o traducir los comentarios -> Los comentarios que quedan son relevantes. Hay que traducirlos.
//NOTA: Debe usarse la BD de test (ver app.config)
QuinixDbContext context = new QuinixDbContext();
var matches = context.Matches;
foreach (var match in matches)
{
context.Remove(match);
}
context.SaveChanges();
Assert.Equal(0, context.Matches.Count());
FootballMatchesWebScrapper mrp = new FootballMatchesWebScrapper(2016, 2016, NodeOperation.SaveToDb, null);
mrp.ExecuteAll();
//Deben haberse creado 841 registros.
Assert.Equal(841, context.Matches.Count());
//Si vuelvo a ejecutar, debe seguir habiendo el mismo número de registros.
mrp.ExecuteAll();
Assert.Equal(841, context.Matches.Count());
}
//Si dos equipos tienen los mismos puntos y han jugado ya dos veces entre ellos, la diferencia de goles en esos dos partidos sirve para desempatar. No se aplica la regla de que valen más los goles anotados como visitante en caso de empate. Ej (1-1), (3-3): el que marcó 3 como visitante no queda por delante. Si no se puede desempatar se devuelve null.
private bool?GenerateParticularRecordTieBreak(TeamAccumulator previous, TeamAccumulator current)
{
QuinixDbContext context = new QuinixDbContext();
List <Match> ParticularRecord = Utils.GetMatches(Season, Division, 1, LastMatchDay).Where(m => m.HomeTeamId == previous.Team.Id && m.AwayTeamId == current.Team.Id || m.AwayTeamId == previous.Team.Id && m.HomeTeamId == current.Team.Id).ToList();
if (ParticularRecord.Count() == 2)
{
Match firstMatch = ParticularRecord.First();
Match secondMatch = ParticularRecord.Last();
bool previousAsHomeFirstMatch = firstMatch.HomeTeamId == previous.Team.Id;
if (previousAsHomeFirstMatch)
{
if (firstMatch.HomeTeamGoals + secondMatch.AwayTeamGoals > firstMatch.AwayTeamGoals + secondMatch.HomeTeamGoals)
{
return(true);
}
else if (firstMatch.HomeTeamGoals + secondMatch.AwayTeamGoals < firstMatch.AwayTeamGoals + secondMatch.HomeTeamGoals)
{
return(false);
}
}
else
{
if (firstMatch.HomeTeamGoals + secondMatch.AwayTeamGoals > firstMatch.AwayTeamGoals + secondMatch.HomeTeamGoals)
{
return(false);
}
else if (firstMatch.HomeTeamGoals + secondMatch.AwayTeamGoals < firstMatch.AwayTeamGoals + secondMatch.HomeTeamGoals)
{
return(true);
}
}
}
return(null);
}
private static bool MatchExists(QuinixDbContext context, Season season, Division division, Team homeTeam, Team awayTeam)
{
return(context.Matches.Any(
m => m.SeasonId == season.Id &&
m.DivisionId == division.Id &&
m.HomeTeamId == homeTeam.Id &&
m.AwayTeamId == awayTeam.Id));
}
public void ExecuteSingle()
{
//NOTE: DB should be populated for season 2016-17 before executing the test.
string resultsFilePath = @"..\..\..\test_data\TestReportGenerator\results.csv";
string comparisonFilePath = @"..\..\..\test_data\TestReportGenerator\classification_comparison.csv";
QuinixDbContext context = new QuinixDbContext();
Season season = context.Seasons.Single(s => s.StartYear == 2016);
Division division = context.Divisions.Single(d => d.Name.Equals("primera"));
ClassificationTable table = new ClassificationTable(season, division, 1, 38, 38);
table.GenerateClassificationTable();
ReportGenerator reportGenerator = new ReportGenerator(table.History, resultsFilePath);
reportGenerator.GenerateReport(38);
Assert.Equal(Utils.GenerateFileHash(resultsFilePath), Utils.GenerateFileHash(comparisonFilePath));
}
public static void Main()
{
//Adjust this values to get the desired classification table.
int seasonYear = 2016;
string divisionName = "primera";
string reportFilePath = @"..\..\..\output\classification_table.csv";
QuinixDbContext context = new QuinixDbContext();
Season season = context.Seasons.Single(s => s.StartYear == seasonYear);
Division division = context.Divisions.Single(d => d.Name.Equals(divisionName));
ClassificationTable table = new ClassificationTable(season, division, 1, 38, 38);
table.GenerateClassificationTable();
ReportGenerator reportGenerator = new ReportGenerator(table.History, reportFilePath);
reportGenerator.GenerateReport(38);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
public ClassificationTable(Season season, Division division, int initialMatchDay, int totalMatchDays, int lastMatchDay)
{
InitialMatchDay = initialMatchDay;
TotalMatchDays = totalMatchDays;
LastMatchDay = lastMatchDay;
QuinixDbContext context = new QuinixDbContext();
Season = season;
Division = division;
History = new List <ClassificationTableItem>();
GlobalAccumulators = new Dictionary <string, TeamAccumulator>();
HomeAccumulators = new Dictionary <string, TeamAccumulator>();
AwayAccumulators = new Dictionary <string, TeamAccumulator>();
List <Team> homeTeamsMatchDay1 = Utils.GetMatches(Season, Division, 1).Select(m => m.HomeTeam).ToList();
List <Team> awayTeamsMatchDay1 = Utils.GetMatches(Season, Division, 1).Select(m => m.AwayTeam).ToList();
List <Team> teams = homeTeamsMatchDay1.Concat(awayTeamsMatchDay1).ToList();
foreach (Team team in teams)
{
GlobalAccumulators.Add(team.Name, new TeamAccumulator(team));
HomeAccumulators.Add(team.Name, new TeamAccumulator(team));
AwayAccumulators.Add(team.Name, new TeamAccumulator(team));
}
}
//Obtiene la última jornada de la temporada (distingue entre divisiones y entre si la temporada ha terminado o no).
private int GetLastMatchDay()
{
QuinixDbContext context = new QuinixDbContext();
return(context.Matches.Where(m => m.SeasonId == CurrentSeason.Id && m.DivisionId == CurrentDivision.Id).Select(m => m.MatchDay).Max());
}
private IEnumerable <Division> GetDivisions()
{
QuinixDbContext context = new QuinixDbContext();
return(context.Divisions.ToList());
}
private IEnumerable <Season> GetSeasons()
{
QuinixDbContext context = new QuinixDbContext();
return(context.Seasons.ToList());
}
public static void SaveToDb(int year, string divisionName, int matchDay, HtmlNode resultNode, string filePath)
{
List <string> data = GetTeamsAndResult(resultNode);
string homeTeamName = data[0];
string awayTeamName = data[1];
string resultString = data[2];
//Partido todavía sin jugar (posiblemente aplazado). No hacemos nada.
Regex validResult = new Regex(@"\d+-\d+");
if (!validResult.Match(resultString).Success)
{
return;
}
int homeTeamGoals = int.Parse(resultString.Split('-')[0]);
int awayTeamGoals = int.Parse(resultString.Split('-')[1]);
QuinixDbContext context = new QuinixDbContext();
Division division = context.Divisions.Single(d => d.Name.Equals(divisionName));
Season season;
if (context.Seasons.Count(s => s.StartYear == year) == 0)
{
season = new Season
{
StartYear = year,
EndYear = year + 1
};
context.Seasons.Add(season);
}
else
{
season = context.Seasons.Single(s => s.StartYear == year);
}
Team homeTeam;
if (context.Teams.Count(t => t.Name.Equals(homeTeamName)) == 0)
{
homeTeam = new Team
{
Name = homeTeamName
};
context.Teams.Add(homeTeam);
}
else
{
homeTeam = context.Teams.Single(t => t.Name.Equals(homeTeamName));
}
Team awayTeam;
if (context.Teams.Count(t => t.Name.Equals(awayTeamName)) == 0)
{
awayTeam = new Team
{
Name = awayTeamName
};
context.Teams.Add(awayTeam);
}
else
{
awayTeam = context.Teams.Single(t => t.Name.Equals(awayTeamName));
}
if (!MatchExists(context, season, division, homeTeam, awayTeam))
{
Model.Match match = new Model.Match
{
Season = season,
Division = division,
MatchDay = matchDay,
HomeTeam = homeTeam,
AwayTeam = awayTeam,
HomeTeamGoals = homeTeamGoals,
AwayTeamGoals = awayTeamGoals
};
context.Matches.Add(match);
}
context.SaveChanges();
}
public static List <Match> GetMatches(Season season, Division division, int firstMatchDay, int lastMatchDay)
{
QuinixDbContext context = new QuinixDbContext();
return(context.Matches.Include(m => m.HomeTeam).Include(m => m.AwayTeam).Where(m => m.SeasonId == season.Id && m.DivisionId == division.Id && m.MatchDay >= firstMatchDay && m.MatchDay <= lastMatchDay).OrderBy(m => m.MatchDay).ToList());
}
public void GenerateClassificationTable()
{
QuinixDbContext context = new QuinixDbContext();
foreach (int matchDay in Enumerable.Range(InitialMatchDay, TotalMatchDays))
{
List <Match> matches = Utils.GetMatches(Season, Division, matchDay);
foreach (Match g in matches)
{
Team homeTeam = g.HomeTeam;
Team awayTeam = g.AwayTeam;
GlobalAccumulators[homeTeam.Name].GamesPlayed++;
HomeAccumulators[homeTeam.Name].GamesPlayed++;
GlobalAccumulators[awayTeam.Name].GamesPlayed++;
AwayAccumulators[awayTeam.Name].GamesPlayed++;
if (g.HomeTeamGoals > g.AwayTeamGoals)
{
TeamWon(GlobalAccumulators[homeTeam.Name], g.AwayTeamGoals);
TeamWon(HomeAccumulators[homeTeam.Name], g.AwayTeamGoals);
TeamLost(GlobalAccumulators[awayTeam.Name], g.AwayTeamGoals);
TeamLost(AwayAccumulators[awayTeam.Name], g.AwayTeamGoals);
}
else if (g.HomeTeamGoals < g.AwayTeamGoals)
{
TeamWon(GlobalAccumulators[awayTeam.Name], g.HomeTeamGoals);
TeamWon(AwayAccumulators[awayTeam.Name], g.HomeTeamGoals);
TeamLost(GlobalAccumulators[homeTeam.Name], g.HomeTeamGoals);
TeamLost(HomeAccumulators[homeTeam.Name], g.HomeTeamGoals);
}
else
{
TeamTied(GlobalAccumulators[homeTeam.Name], g.HomeTeamGoals);
TeamTied(HomeAccumulators[homeTeam.Name], g.HomeTeamGoals);
TeamTied(GlobalAccumulators[awayTeam.Name], g.AwayTeamGoals);
TeamTied(AwayAccumulators[awayTeam.Name], g.AwayTeamGoals);
}
GlobalAccumulators[homeTeam.Name].GoalsInFavour += g.HomeTeamGoals;
HomeAccumulators[homeTeam.Name].GoalsInFavour += g.HomeTeamGoals;
GlobalAccumulators[homeTeam.Name].GoalsAgainst += g.AwayTeamGoals;
HomeAccumulators[homeTeam.Name].GoalsAgainst += g.AwayTeamGoals;
GlobalAccumulators[awayTeam.Name].GoalsInFavour += g.AwayTeamGoals;
AwayAccumulators[awayTeam.Name].GoalsInFavour += g.AwayTeamGoals;
GlobalAccumulators[awayTeam.Name].GoalsAgainst += g.HomeTeamGoals;
AwayAccumulators[awayTeam.Name].GoalsAgainst += g.HomeTeamGoals;
}
//TODO: Las reglas para desempatar o para asignar puntos podrían depender de la temporada, si me voy muy atrás.
List <TeamAccumulator> classif = GlobalAccumulators.Values.OrderByDescending(t => t.Points).ToList();
List <TeamAccumulator> aux = TieBreak(classif);
while (!EqualClassifications(classif, aux))
{
classif = aux;
aux = TieBreak(classif);
}
classif = aux; //Por si no hay ningún desempate que hacer.
int i = 1;
foreach (TeamAccumulator accumulator in classif)
{
History.Add(new ClassificationTableItem(i, matchDay, new TeamAccumulator(accumulator), new TeamAccumulator(HomeAccumulators[accumulator.Team.Name]), new TeamAccumulator(AwayAccumulators[accumulator.Team.Name])));
i++;
}
}
}
