// GET: /user/statistics/player/{playerName}/league/{leagueName}/season/{season}/round/{round}
public ActionResult PlayerRound(string playerName, string leagueName, string season, int round)
{
var playerId = Players.GetIdByName(playerName);
var leagueId = Leagues.GetIdByName(leagueName);
var seasonPeriod = Seasons.GetSeasonPeriodFromUrlParameter(season, '-');
var seasonId = Seasons.GetIdByPeriod(seasonPeriod);
var leaguesSeasonsId = LeaguesSeasons.GetIdByLeagueAndSeason(leagueId, seasonId);
var roundId = Rounds.GetRoundId(round, leaguesSeasonsId);
var statistics = Statistics.PlayerRoundStats(playerId, roundId);
return(View("PlayerLeague", statistics));
}
public void Create(Leagues instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
else
{
Db.Leagues.Add(instance);
this.SaveChanges();
}
}
public void Update(Leagues instance)
{
if (instance == null)
{
throw new ArgumentNullException("instance");
}
else
{
Db.Entry(instance).State = EntityState.Modified;
this.SaveChanges();
}
}
public async Task <IActionResult> Create([Bind("Id,Name,Code,Country")] Leagues leagues)
{
if (ModelState.IsValid)
{
_context.Add(leagues);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["Country"] = new SelectList(_context.Countries, "Id", "Name", leagues.Country);
return(View(leagues));
}
public ActionResult Edit(Leagues leagues)
{
if (leagues != null && ModelState.IsValid)
{
_leagues.Update(leagues);
return(RedirectToAction("Index", "cfgPlayGames"));
}
else
{
return(RedirectToAction("Index"));
}
}
public bool GenerateSchedule()
{
Leagues newLeagueEntity = new Leagues
{
Name = this.NewLeagueName
};
DateTime yearOfStart = new DateTime(this.NewLeagueYearOfStart, 1, 1);
LeagueEntityToLibraryAdapter newLeagueAdapter = new LeagueEntityToLibraryAdapter();
newLeagueAdapter.Adapt(newLeagueEntity);
RoundRobinScheduler scheduler = new RoundRobinScheduler();
scheduler.LoadLeague(newLeagueAdapter);
List <ITeam> listOfTeamsAdapter = new List <ITeam>();
foreach (Teams team in this.TeamsForNewLeague)
{
TeamEntityToLibraryAdapter teamAdapter = new TeamEntityToLibraryAdapter();
teamAdapter.Adapt(team);
listOfTeamsAdapter.Add(teamAdapter);
}
scheduler.LoadTeams(listOfTeamsAdapter);
scheduler.YearOfStart = yearOfStart;
scheduler.GenerateSchedule();
List <IMatch> listOfMatchesFromAlgorithm = scheduler.GetSchedule();
List <Matches> listOfMatchesEntities = new List <Matches>();
foreach (IMatch match in listOfMatchesFromAlgorithm)
{
Matches m = new Matches()
{
TimeOfPlay = match.TimeOfPlay,
HomeTeamId = match.HomeTeam.Id,
AwayTeamId = match.AwayTeam.Id,
};
Context.Matches.Add(m);
}
Context.Leagues.Add(newLeagueEntity);
Context.SaveChanges();
return(true);
}
private void HandleLeagueChanged(Leagues oldLeague)
{
var newLeague = Properties.Settings.Default.League;
if (oldLeague != newLeague)
{
var favoriteTeamDialog = new FavoriteTeam
{
ShowClosingMessage = false
};
favoriteTeamDialog.ShowDialog(this);
}
}
public void AddSeasonAction()
{
var vm = new LeagueViewModel(SimpleIoc.Default.GetInstance <IOpenLigaService>());
var message = new ModalDialogMessage {
ViewModel = vm
};
this.MessengerInstance.Send(message);
if (message.DialogResult == true)
{
Leagues.Add(vm);
}
}
public List<ITeamResults> GetResults(Leagues league)
{
List<ITeamResults> teams = new List<ITeamResults>();
HtmlDocument doc = new HtmlDocument();
var stream =
GetPageStream(GuardianLeagueMappings.GetUriForLeague(league));
doc.Load(stream, Encoding.UTF8);
var tables = doc.DocumentNode.SelectNodes("//table[@class='table-football']");
var rows = tables[0].SelectNodes(".//tr");
// Pos Team P W D L F A W D L F A W D L F A GD Pts
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 19 20
foreach (var row in rows)
{
HomeResultSet home = new HomeResultSet();
AwayResultSet away = new AwayResultSet();
HtmlNodeCollection cells = row.SelectNodes(".//td");
if (cells == null)
{
continue;
}
string team = cells[1].InnerText;
// Cell has a td which has an a with a href..
string link = string.Concat(root, cells[1].ChildNodes.Single().Attributes["href"].Value);
home.Won = int.Parse(cells[3].InnerText);
home.Drawn = int.Parse(cells[4].InnerText);
home.Lost = int.Parse(cells[5].InnerText);
home.GoalsScored = int.Parse(cells[6].InnerText);
home.GoalsConceded = int.Parse(cells[7].InnerText);
away.Won = int.Parse(cells[8].InnerText);
away.Drawn = int.Parse(cells[9].InnerText);
away.Lost = int.Parse(cells[10].InnerText);
away.GoalsScored = int.Parse(cells[11].InnerText);
away.GoalsConceded = int.Parse(cells[12].InnerText);
teams.Add(new HomeAndAwayTeamResults(team, link, home, away));
}
teams.Sort(new TeamResultsComparer());
return teams;
}
private async Task <bool> FetchAndAddRateDataToDictionaryAsync(Key key, Leagues league = Leagues.Default)
{
if (key.IsFossil())
{
foreach (var rateData in await FetchFossilRateAsync())
{
RateDataDictionary[key] = rateData;
}
return(true);
}
return(false);
}
public void Import(XDocument file, FootballEntities context)
{
var leaguesNodes = file.XPathSelectElements("leagues-and-teams/league");
foreach (var leagueNode in leaguesNodes)
{
// parse league info
// all optional
var tempLeague = new Leagues();
string leagueName = null;
// check if there is a league
if (leagueNode.Element("league-name") != null)
{
leagueName = leagueNode.Element("league-name").Value;
var league = context.Leagues.FirstOrDefault(l => l.LeagueName == leagueName);
// league exists + add league
if (league != null)
{
Console.WriteLine("Existing league: " + leagueName);
AddTeamsToLeagueAndDb(context, leagueNode, league);
}
// league doesn't exist - create it
else
{
var newLeague = new Leagues();
newLeague.LeagueName = leagueName;
context.Leagues.Add(newLeague);
context.SaveChanges();
Console.WriteLine("Created league: " + leagueName);
AddTeamsToLeagueAndDb(context, leagueNode, newLeague);
}
}
//AddTeamsToLeagueAndDb(context, leagueNode, tempLeague);
// Add the league to the DB
// context.Leagues.Add(tempLeague);
else
{
AddTeamsToDb(context, leagueNode);
}
context.SaveChanges();
}
}
/// <summary>
/// Initializes a new instance of the Clash of Clans API
/// </summary>
/// <param name="tokens">Your personal API key(s)</param>
public ClashOfClansClient(params string[] tokens)
{
TokenValidator.Validate(tokens);
_options = new ClashOfClansOptionsInternal(tokens);
var gameData = new GameData(_options);
Clans = new Clans(gameData);
Locations = new Locations(gameData);
Leagues = new Leagues(gameData);
Players = new Players(gameData);
Labels = new Labels(gameData);
GoldPass = new GoldPass(gameData);
}
private void ReloadLeagues(List <League> leagues)
{
Leagues.Clear();
foreach (var league in leagues.OrderBy(l => l.Name)) //pero mas mejor si lo mando desde el api
{
Leagues.Add(new LeagueItemViewModel
{
LeagueId = league.LeagueId,
Logo = league.Logo,
Name = league.Name,
Teams = league.Teams,
});
}
}
private string getLeagueKey(Leagues league)
{
switch (league)
{
case Leagues.LigaSantander:
return(KeyLigaSantander);
case Leagues.Liga123:
return(KeyLiga123);
case Leagues.PremierLeague:
return(KeyPremier);
case Leagues.ChampionShip:
return(KeyChampionship);
case Leagues.Bundesliga:
return(KeyBundesliga);
case Leagues.Bundesliga2:
return(KeyBundesliga2);
case Leagues.SeriaA:
return(KeySerieA);
case Leagues.Ligue1:
return(KeyLigue1);
case Leagues.Ligue2:
return(KeyLigue2);
case Leagues.Eredivise:
return(KeyEredivise);
case Leagues.TurqueiLeague:
return(KeyTurquei);
case Leagues.BelgiumLeague:
return(KeyBelgium);
case Leagues.ScotlandPremierShip:
return(KeyScotlandPremierShip);
case Leagues.ScotlandChampoinShip:
break;
}
return("");
}
private void AddAllLeagues()
{
foreach (var league in _leagueAndSeasonInfoService.GetAllLeagueInfo())
{
foreach (var season in league.Seasons)
{
Leagues.Add(LeagueViewModel.Create(league.League, season));
}
}
if (Leagues.Count > 0)
{
SelectedLeague = Leagues[0];
}
}
public Master_Basketball(Leagues leagues) : base()
{
Console.WriteLine("Введите количество очков за всё время: ");
try
{
Point = Convert.ToInt32(Console.ReadLine());
}
catch (Exception)
{
Point = 0;
}
this.leagues = leagues;
WeightBenchPress = BenchPress(WeightBenchPress);
Speed = RunSpeed(Speed);
}
public void Parse(string response)
{
XmlDocument xml = new XmlDocument(); //* create an xml document object.
XmlTextReader xmlTextReader = new XmlTextReader(new StringReader(response));
xml.Load(xmlTextReader);
try
{
XmlNodeList xmlLeagues = xml.SelectNodes("GetCategoryLeagues/Leagues/League");
leagues = LeagueParsing.ParseLeagues(xmlLeagues);
}
catch
{
throw new InvalidStateException("Answer from the server is not well-formed.");
}
}
public static IActionResult Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
string userId = req.Query["userid"].ToString();
var endpoint = new MflEndpoint();
var leaguesEndpoint = new Uri($"{endpoint.Host}/{endpoint.Year}/export?TYPE=myleagues&FRANCHISE_NAMES=1&JSON=1");
string leaguesResponse = MflEndpointController.GetResponseString(leaguesEndpoint, endpoint, userId).Result;;
var leagues = new Leagues(leaguesResponse);
return(userId != null
? (ActionResult) new OkObjectResult(leagues.LeagueList)
: new BadRequestObjectResult("Please pass a name on the query string or in the request body"));
}
private void GotLeaguesForPlayer(SummonerLeaguesDTO result)
{
Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(() =>
{
if (result.SummonerLeagues != null && result.SummonerLeagues.Count > 0)
{
LeagueHeader.Visibility = System.Windows.Visibility.Visible;
Leagues overview = LeaguesContainer.Content as Leagues;
overview.Update(result);
}
else
{
LeagueHeader.Visibility = System.Windows.Visibility.Collapsed;
}
}));
}
public static LeagueConstants For(Leagues league)
{
switch (league)
{
case Leagues.Rounders2019: return(Rounders2019);
case Leagues.CrossCountryRivals2019: return(CrossCountryRivals2019);
case Leagues.Rounders2020: return(Rounders2020);
case Leagues.Rounders2021: return(Rounders2021);
case Leagues.Rounders2022: return(Rounders2022);
default: return(null);
}
}
public IActionResult Leagues()
{
var model = new List <League>();
HttpClient httpClient = new HttpClient()
{
BaseAddress = new Uri(url)
};
var json = httpClient.GetStringAsync("all_leagues.php?s=Soccer").Result;
Leagues myDeserializedClass = JsonConvert.DeserializeObject <Leagues>(json);
model = myDeserializedClass.leagues;
return(View(model));
}
public static Leagues ParseLeagues(XmlNodeList leaguesList)
{
Leagues l = new Leagues();
if (leaguesList.Count > 0)
{
foreach (XmlNode league in leaguesList)
{
int id = int.Parse(league["ID"].InnerText);
bool leagueLoaded = bool.Parse(league["Loaded"].InnerText);
Rounds rounds = RoundParsing.ParseRounds(league.SelectNodes("Rounds/Round"));
l.Add(new League(id, league["Name"].InnerText, leagueLoaded, rounds));
}
}
return l;
}
static Leagues LeagueFromString(string league)
{
Leagues ret = Leagues.None;
league = league.ToLower();
if (league == null)
{
ret = Leagues.None;
}
else
{
if ((league == "bronze") || (league == "bronzie") || (league == "bronzer") || league.StartsWith("b"))
{
ret = Leagues.Bronze;
}
else if ((league == "silver") || league.StartsWith("s"))
{
ret = Leagues.Silver;
}
else if ((league == "gold") || league.StartsWith("go"))
{
ret = Leagues.Gold;
}
else if ((league == "platinum") || (league == "plat") || league.StartsWith("p"))
{
ret = Leagues.Platinum;
}
else if ((league == "diamond") || league.StartsWith("d"))
{
ret = Leagues.Diamond;
}
else if ((league == "master") || (league == "masters") || league.StartsWith("m"))
{
ret = Leagues.Master;
}
else if ((league == "grandmaster") || (league == "grand master") || (league == "gm") || (league == "grandmasters") || league.StartsWith("gr"))
{
ret = Leagues.Grandmaster;
}
}
return(ret);
}
public static string GetUriForLeague(Leagues league)
{
switch (league)
{
case Leagues.EnglishPremierLeague:
return "http://www.theguardian.com/football/premierleague/table";
case Leagues.EnglishChampionship:
return "http://www.theguardian.com/football/championship/table";
case Leagues.EnglishLeagueOne:
return "http://www.theguardian.com/football/leagueonefootball/table";
case Leagues.EnglishLeagueTwo:
return "http://www.theguardian.com/football/leaguetwofootball/table";
case Leagues.SPL:
return "http://www.theguardian.com/football/scottishpremierleague/table";
case Leagues.DivisionOne:
return "http://www.theguardian.com/football/scottish-division-one/table";
case Leagues.DivisionTwo:
return "http://www.theguardian.com/football/scottish-division-two/table";
case Leagues.DivisionThree:
return "http://www.theguardian.com/football/scottish-division-three/table";
case Leagues.LaLiga:
return "http://www.theguardian.com/football/laligafootball/table";
case Leagues.Ligue1:
return "http://www.theguardian.com/football/ligue1football/table";
case Leagues.Bundesliga:
return "http://www.theguardian.com/football/bundesligafootball/table";
case Leagues.SeriaA:
return "http://www.theguardian.com/football/serieafootball/table";
default:
throw new NotImplementedException();
}
}
string SendResponse(HttpListenerRequest request)
{
try
{
string[] urlParts = request.RawUrl.Split('/');
string lastPart = urlParts.Length > 0? urlParts[urlParts.Length - 1] : null;
Holder holder = null;
if (Leagues.Count == 1)
{
holder = Leagues.First();
}
else if (urlParts.Length > 1)
{
holder = Leagues.Find(x => x.Key == urlParts[1]);
}
if (request.RawUrl == "/")
{
if (Leagues.Count == 1)
{
return(ReportPages.OverviewPage(holder, false, ReportPages.GameHyper, OutputFormat.Svg));
}
else
{
return(ReportPages.RootPage(Leagues));
}
}
else if (lastPart.EndsWith(".html"))
{
return(HtmlResponse(request.RawUrl, lastPart, holder));
}
else
{
return(RestResponse(request));
}
}
catch (Exception ex)
{
return("<html><body>\n" + ex.Message + "\n<br/><br/>\n" + ex.StackTrace + "</body></html>");
throw;
}
}
protected void Page_Load(object sender, EventArgs e)
{
Leagues a = new Leagues();
a.userid = Convert.ToInt32(Session["id"]);
Random RAND = new Random();
for (int i = 0; i < a.showLeagues().Count; i++)
{
if (!Page.IsPostBack)
{
leagCreate.InnerHtml += @"<tr class=""click-row"" data-href=""#"">
<th scope=""row"">" + (i + 1) + @"</th>
<td>" + a.showLeagues()[i].LeagueName + @"</td>
<td>" + a.showLeagues()[i].Tourname + @"</td>
<td>" + RAND.Next(20, 100) + @"+</td>
</tr>";
}
}
int j = 0;
foreach (var item in new ParticipantsManager().JoinedLeagues(Convert.ToInt32(Session["id"])))
{
if (!Page.IsPostBack)
{
leaguesP.InnerHtml += @"<tr class=""click-row"" data-href=""#"">
<th scope=""row"">" + (j + 1) + @"</th>
<td>" + item.LeagueName + @"</td>
<td>" + item.Tourname + @"</td>
<td>" + RAND.Next(20, 100) + @"+</td>
</tr>";
j++;
}
}
}
/// <summary>
/// Метод принимает название лиги и возвращает ссылку на страницу предстоящих матчей этой лиги на FlashScore.
/// </summary>
/// <param name="league">Название лиги.</param>
/// <returns>Ссылка на страницу FlashScore.</returns>
public static string ToLink(this Leagues league)
{
switch (league)
{
case Leagues.ProLeagueMen:
return("https://www.flashscore.ru/table-tennis/others-men/liga-pro/fixtures/");
case Leagues.TTCupMen:
return("https://www.flashscore.ru/table-tennis/others-men/tt-cup/fixtures/");
case Leagues.WinCupMen:
return("https://www.flashscore.ru/table-tennis/others-men/win-cup/fixtures/");
case Leagues.SetkaCupMen:
return("https://www.flashscore.ru/table-tennis/others-men/setka-cup/fixtures/");
default:
return(String.Empty);
}
}
public async Task <Leagues> GetLeagues()
{
Leagues leagues = memoryCache.Get <Leagues>("Leagues");
if (leagues != null)
{
return(leagues);
}
else
{
leagues = await client.GetFromJsonAsync <Leagues>("/api/leagues?page=1&limit=100");
foreach (var l in leagues.LeagueList)
{
l.Image = await client.GetByteArrayAsync($"/api/leagues/{l.Id}/image");
}
memoryCache.Set("Leagues", leagues);
}
return(leagues);
}
private void InitializeData()
{
DatabaseSourceDefinitor.CreateDatabaseIfNotExist();
DatabaseSchemaUpdater.Update();
using (var repository = new LeagueRepository(DatabaseSourceDefinitor.ConnectionString))
{
Leagues = repository.GetLeagues();
}
if (Leagues.Length > 0)
{
int lastSeason = Leagues.Max(t => t.Season);
League = Leagues.First(t => t.Season == lastSeason);
Tour = League.Tours[0];
using (var repository = new GameRepository(DatabaseSourceDefinitor.ConnectionString))
{
GamesInTour = repository.GetGamesInTour(Tour.Id);
}
League.Calculate();
TeamsStat = League.TeamStats;
}
}
/// <summary>
/// Асинхронный метод получения матчей из нескольких лиг через флаг.
/// </summary>
/// <param name="leagues">Перечисление лиг в виде флагов.</param>
/// <returns>Список матчей указанных лиг.</returns>
public async Task <List <Match> > GetMatchesOfSomeLeagues(Leagues leagues, DateTime minStartTime, int minH2H)
{
List <Match> AllMatches = new List <Match>();
if (leagues.HasFlag(Leagues.ProLeagueMen))
{
AllMatches.AddRange(await GetMatchesOfLeague(Leagues.ProLeagueMen, minStartTime, minH2H));
}
if (leagues.HasFlag(Leagues.TTCupMen))
{
AllMatches.AddRange(await GetMatchesOfLeague(Leagues.TTCupMen, minStartTime, minH2H));
}
if (leagues.HasFlag(Leagues.WinCupMen))
{
AllMatches.AddRange(await GetMatchesOfLeague(Leagues.WinCupMen, minStartTime, minH2H));
}
if (leagues.HasFlag(Leagues.SetkaCupMen))
{
AllMatches.AddRange(await GetMatchesOfLeague(Leagues.SetkaCupMen, minStartTime, minH2H));
}
return(AllMatches);
}
private void GenerateSchedule()
{
int lastSeasonNumber = Leagues.Length == 0 ? 0 : Leagues.Max(t => t.Season);
new LeagueModel().GenerateSeason(lastSeasonNumber + 1);
using (var repository = new LeagueRepository(DatabaseSourceDefinitor.ConnectionString))
{
Leagues = repository.GetLeagues();
}
if (Leagues.Length > 0)
{
int lastSeason = Leagues.Max(t => t.Season);
League = Leagues.First(t => t.Season == lastSeason);
Tour = League.Tours[0];
using (var repository = new GameRepository(DatabaseSourceDefinitor.ConnectionString))
{
GamesInTour = repository.GetGamesInTour(Tour.Id);
}
League.Calculate();
TeamsStat = League.TeamStats;
}
}
public async Task <Leagues> GetInfoAsync()
{
Leagues basketballLeagues = null;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Get,
RequestUri = new Uri($"{Config.ApiUrl}/leagues"),
Headers =
{
{ Config.ApiKeyHeader, Config.ApiKey },
{ Config.ApiHostHeader, Config.ApiHost },
},
};
var response = await client.SendAsync(request);
if (response.IsSuccessStatusCode)
{
basketballLeagues = _serializerService.Deserialize <Leagues>(await response.Content.ReadAsStringAsync());
}
return(basketballLeagues);
}
public void Seed()
{
var ligaBbva = new Leagues
{
Name = "Liga BBVA"
};
_session.Save(ligaBbva);
var ligaPremier = new Leagues
{
Name = "Liga Premier Inglesa"
};
_session.Save(ligaPremier);
var ligaItaliana = new Leagues
{
Name = "Seria A"
};
_session.Save(ligaItaliana);
}
/// <summary>
/// Преобразует объект Enum, в строковое представление.
/// </summary>
/// <param name="l">Объект лиги.</param>
/// <returns>Строковое представление.</returns>
public static string ToTextString(this Leagues l)
{
string UaFlag = "\U0001F1FA\U0001F1E6";
string RuFlag = "\U0001F1F8\U0001F1EE";
switch (l)
{
case Leagues.ProLeagueMen:
return($"\" {RuFlag} Лига ПРО {RuFlag} \"");
case Leagues.TTCupMen:
return($"\" {UaFlag} TT CUP {UaFlag} \"");
case Leagues.WinCupMen:
return($"\"{UaFlag} Win CUP {UaFlag} \"");
case Leagues.SetkaCupMen:
return($"\"{UaFlag} Setka Cup {UaFlag} \"");
default:
return(string.Empty);
}
}
private string GetDescription(Leagues league)
{
MemberInfo val = league.GetType().GetMember(league.ToString()).Single();
return val.GetCustomAttribute<DescriptionAttribute>().Description;
}
public List<ITeamResults> GetResults(Leagues league)
{
List<ITeamResults> teams = new List<ITeamResults>();
HtmlDocument doc = new HtmlDocument();
var stream =
GetPageStream(GuardianLeagueMappings.GetUriForLeague(league));
doc.Load(stream, Encoding.UTF8);
var table = doc.DocumentNode.SelectNodes("//table").FirstOrDefault();
if (table == null)
{
throw new InvalidOperationException("Guardian have changed their site again - can't find table.");
}
var body = table.SelectNodes(".//tbody").FirstOrDefault();
if (body == null)
{
throw new InvalidOperationException("Guardian have changed their site again - can't find table body.");
}
var rows = body.SelectNodes(".//tr");
if (rows == null)
{
throw new InvalidOperationException("Guardian have changed their site again - can't find rows.");
}
foreach (var row in rows)
{
CombinedResultSet results = new CombinedResultSet();
HtmlNodeCollection cells = row.SelectNodes(".//td");
if (cells == null)
{
throw new InvalidOperationException("Guardian have changed their site again - can't find cells.");
}
string team = cells[1].InnerText;
string link = "Link is broken";
var spans = cells[1].SelectNodes(".//span");
var linkCells = spans?.First().SelectNodes(".//a");
var href = linkCells?.First().Attributes["href"];
if (href != null)
{
link = string.Concat(root, href.Value);
}
/*
Pos Team P W D L F A GD Pts Form
1 Arsenal 1 1 0 0 2 1 1 3
<tr class="">
<td class="table-column--sub">3</td> <-- TD 0 -->
<td class="table-column--main"> <-- TD 1 -->
<span class="team-name" data-abbr="ARS">
<a href="/football/arsenal" data-link-name="View team" class="team-name__long">
Arsenal
</a>
</span>
</td>
<td>1</td> <-- TD 2, played, which is calculated -->
<td class="table-column--importance-1">1</td> <-- TD 3 -->
<td class="table-column--importance-1">0</td> <-- TD 4 -->
<td class="table-column--importance-1">0</td> <-- TD 5 -->
<td class="table-column--importance-1">2</td> <-- TD 6 -->
<td class="table-column--importance-1">1</td> <-- TD 7 -->
<td class="table-column--importance-3">1</td> <-- TD 8 -->
<td>
<b>3</b> <-- TD 9 - note b tag -->
</td>
<td class="table-column--importance-2 football-stat--form team__results--thin"><-- TD 10 - form - TODO -->
<div class="team__results">
<span class="team-result team-result--won" data-foe="C Palace" data-score="2" data-score-foe="1" title="Won 2-1 against C Palace">
<span class="u-h">Won against C Palace</span>
</span>
</div>
</td>
</tr>
*/
// ReSharper disable UnusedVariable
var played = int.Parse(cells[2].InnerText);
int gd = int.Parse(cells[8].InnerText);
int points = int.Parse(cells[9].InnerText);
// ReSharper restore UnusedVariable
results.Won = int.Parse(cells[3].InnerText);
results.Drawn = int.Parse(cells[4].InnerText);
results.Lost = int.Parse(cells[5].InnerText);
results.GoalsScored = int.Parse(cells[6].InnerText);
results.GoalsConceded = int.Parse(cells[7].InnerText);
teams.Add(new CombinedTeamResult(team, link, results));
}
teams.Sort(new TeamResultsComparer());
return teams;
}
