public async Task <IActionResult> MoveToBottom(int id, string scoring, string playerPosition)
{
PlayerRanking playerToMove = await _rankingRepository.GetByIdAsync(id);
IEnumerable <PlayerRanking> allPlayerRanks = await _rankingRepository.ListAllAsync();
IEnumerable <Player> allPlayers = await _playerRepository.ListAllAsync();
List <PlayerRanking> playersOfPosition = _rankingRepository.CreateListOfPlayersOfPosition(playerToMove, allPlayerRanks, allPlayers);
await _rankingRepository.MoveToBottom(playerPosition, scoring, allPlayerRanks, playersOfPosition, playerToMove);
if (playerPosition == "All Players")
{
return(RedirectToAction(scoring));
}
if (playerPosition != "All Players")
{
return(RedirectToAction(scoring, new
{
playerPosition
}));
}
else
{
return(RedirectToAction("Standard"));
}
}
public async Task <IActionResult> MovePlayers(int id, string scoring, string playerPosition, int direction)
{
try
{
PlayerRanking playerRankingToChange = await _rankingRepository.GetByIdAsync(id);
List <PlayerRanking> playerRankingList = await _rankingRepository.SwapPlayerRanks(playerRankingToChange, direction, scoring, playerPosition);
Player playerToChange = await _playerRepository.GetByIdAsync(playerRankingList[0].PlayerId);
Player otherPlayer = await _playerRepository.GetByIdAsync(playerRankingList[1].PlayerId);
if (playerToChange.PlayerPos == otherPlayer.PlayerPos)
{
await _rankingRepository.UpdatePosRanks(playerRankingList[0], playerRankingList[1], scoring, direction);
}
if (playerPosition == "All Players")
{
return(RedirectToAction(scoring));
}
else
{
return(RedirectToAction(scoring, new
{
playerPosition
}));
}
}
catch
{
//todo log exception
}
return(RedirectToAction(scoring));
}
/// <summary>
/// Updates the provided rankings based on the points and the category
/// </summary>
private void UpdateRankingsFromRow(PlayerRanking pr, int points, Category category)
{
switch (category)
{
case Category.Level:
pr.LevelPoints = points;
break;
case Category.MS:
case Category.WS:
pr.SinglesPoints = points;
break;
case Category.MD:
case Category.WD:
pr.DoublesPoints = points;
break;
case Category.MXD:
case Category.WXD:
pr.MixPoints = points;
break;
default:
throw new ArgumentException($"Category could not be recognised. Category is: {category}");
}
}
public async Task <List <PlayerRankingModel> > CreatePlayerViewModel(IRankingRepository rankingRepository, IPlayerRepository playerRepository)
{
IEnumerable <Player> allPlayers = await playerRepository.ListAllAsync();
List <PlayerRankingModel> playerRankingModelList = new List <PlayerRankingModel>();
foreach (Player player in allPlayers)
{
PlayerRankingModel playerRankingModelToAdd = new PlayerRankingModel();
try
{
PlayerRanking PR = await rankingRepository.GetByPlayerIdAsync(player.PlayerId);
playerRankingModelToAdd.playerRanking = PR;
}
catch
{
PlayerRanking PR = new PlayerRanking
{
PlayerId = player.PlayerId
};
playerRankingModelToAdd.playerRanking = PR;
}
finally
{
playerRankingModelToAdd.playerToRank = player;
playerRankingModelList.Add(playerRankingModelToAdd);
}
}
return(playerRankingModelList);
}
public async Task <List <PlayerRankingModel> > CreatePlayerViewModel(IRankingRepository rankingRepository, IPlayerRepository playerRepository, int profileID)
{
int defaultProfileID = 2025;
IEnumerable <Player> allPlayers = await playerRepository.ListAllAsync();
IEnumerable <PlayerRanking> allRanksofProfile = await rankingRepository.GetAllRanksByProfileId(profileID);
List <PlayerRankingModel> playerRankingModelList = new List <PlayerRankingModel>();
foreach (Player player in allPlayers)
{
PlayerRankingModel playerRankingModelToAdd = new PlayerRankingModel();
PlayerRanking PR = allRanksofProfile.FirstOrDefault(x => x.PlayerId == player.PlayerId);
playerRankingModelToAdd.playerRanking = PR;
playerRankingModelToAdd.playerToRank = player;
playerRankingModelToAdd.playerRanking.TestUserProfileId = profileID;
playerRankingModelList.Add(playerRankingModelToAdd);
}
if (playerRankingModelList.Count > 0)
{
return(playerRankingModelList);
}
else
{
foreach (Player player in allPlayers)
{
PlayerRankingModel playerRankingModelToAdd = new PlayerRankingModel();
try
{
PlayerRanking PR = await rankingRepository.GetByPlayerIdAsync(player.PlayerId);
if (PR.TestUserProfileId == defaultProfileID)
{
PR.TestUserProfileId = profileID;
playerRankingModelToAdd.playerRanking = PR;
await _rankingRepository.AddAsync(PR);
}
}
catch
{
PlayerRanking PR = new PlayerRanking
{
PlayerId = player.PlayerId
};
playerRankingModelToAdd.playerRanking = PR;
}
finally
{
playerRankingModelToAdd.playerToRank = player;
playerRankingModelList.Add(playerRankingModelToAdd);
}
}
return(playerRankingModelList);
}
}
public PlayerRankingControl(PlayerRanking item, int steps, FrameworkElement container)
: base(item, steps, v => System.Convert.ToInt32(v), container)
{
InitializeComponent();
RankLabel = PlayerRankLabel;
MainPanel = PlayerMainCanvas;
ValueLabel = PointsLabel;
ArrangeControl(false);
}
private static List <RankingSnapshot> ScrapeRankingForTeam(int teamId, List <WeekEntry> weeks)
{
Console.WriteLine($"Scraping for team {teamId}");
List <RankingSnapshot> rankings = new List <RankingSnapshot>();
foreach (var week in weeks)
{
var rankingSnapshot = new RankingSnapshot();
rankingSnapshot.Week = week;
Console.WriteLine($"Scraping week {week}");
var html = "http://sb.tournamentsoftware.com/ranking/category.aspx"
.AddQueryParam("id", week.Id)
.AddQueryParam("category", 2338)
.AddQueryParam("C2338FOG", teamId)
.GetStringFromUrl();
var doc = new HtmlDocument();
doc.LoadHtml(html);
var rows = doc.QuerySelectorAll("tr");
for (int i = 2; i < rows.Count; ++i)
{
var row = rows[i].ChildNodes.Select(cn => cn.InnerText).ToList();
if (row.Count < 11)
{
continue; // first, 2nd alnd last has different row.Count...
}
var playerLink = rows[i].ChildNodes[4].ChildNodes[0].GetAttributeValue("href", string.Empty);
var playerIdStartPos = playerLink.LastIndexOf("player=");
var ranking = new PlayerRanking()
{
Id = int.Parse(playerLink.Substring(playerIdStartPos + 7 + 1)), // TODO int.Parse(System.Web.HttpUtility.ParseQueryString(rows[i].ChildNodes[4].ChildNodes[0].GetAttributeValue("href")).Get("player")),
FullName = row[4],
Points = int.Parse(row[6]),
InterclubPoints = int.Parse(row[7]),
TotalPoints = int.Parse(row[9]),
Level = row[11],
TournamentCount = int.Parse(row[10])
};
rankingSnapshot.PlayerRankings.Add(ranking);
}
rankings.Add(rankingSnapshot);
}
return(rankings);
}
private void CalculateAndSortPlayersScores()
{
_playersRankings = new List <PlayerRanking>(_players.Count);
foreach (DBPlayer player in _players)
{
string teamName = string.Empty;
if (_tournament.IsTeams)
{
teamName = _teams.Find(x => x.TeamId == player.PlayerTeamId).TeamName;
}
string countryImageUrl = _db.GetCountryImageUrl(player.PlayerCountryName);
PlayerRanking playerRanking = new PlayerRanking(player.PlayerId, player.PlayerName,
player.PlayerTeamId, teamName, player.PlayerCountryName, countryImageUrl,
CountryFlags.GetFlagImage(player.PlayerCountryName));
List <DBTable> playerTables = _tables.FindAll(x =>
player.PlayerId == x.Player1Id || player.PlayerId == x.Player2Id ||
player.PlayerId == x.Player3Id || player.PlayerId == x.Player4Id);
foreach (DBTable table in playerTables)
{
if (player.PlayerId.ToString().Equals(table.PlayerEastId))
{
playerRanking.PlayerPoints += table.PlayerEastPoints.Equals(string.Empty) ? 0 : float.Parse(table.PlayerEastPoints);
playerRanking.PlayerScore += table.PlayerEastScore.Equals(string.Empty) ? 0 : int.Parse(table.PlayerEastScore);
}
else if (player.PlayerId.ToString().Equals(table.PlayerSouthId))
{
playerRanking.PlayerPoints += table.PlayerSouthPoints.Equals(string.Empty) ? 0 : float.Parse(table.PlayerSouthPoints);
playerRanking.PlayerScore += table.PlayerSouthScore.Equals(string.Empty) ? 0 : int.Parse(table.PlayerSouthScore);
}
else if (player.PlayerId.ToString().Equals(table.PlayerWestId))
{
playerRanking.PlayerPoints += table.PlayerWestPoints.Equals(string.Empty) ? 0 : float.Parse(table.PlayerWestPoints);
playerRanking.PlayerScore += table.PlayerWestScore.Equals(string.Empty) ? 0 : int.Parse(table.PlayerWestScore);
}
else
{
playerRanking.PlayerPoints += table.PlayerNorthPoints.Equals(string.Empty) ? 0 : float.Parse(table.PlayerNorthPoints);
playerRanking.PlayerScore += table.PlayerNorthScore.Equals(string.Empty) ? 0 : int.Parse(table.PlayerNorthScore);
}
}
_playersRankings.Add(playerRanking);
}
_playersRankings = _playersRankings.OrderByDescending(x => x.PlayerPoints).ThenByDescending(x => x.PlayerScore).ToList();
for (int i = 0; i < _playersRankings.Count; i++)
{
_playersRankings[i].Order = i + 1;
}
}
public void AdicionaPontos()
{
PlayerRanking a = new PlayerRanking();
Ranking r = new Ranking();
string m_XmlTextAssetPath = Application.dataPath.ToString() + @"/Resources/" + strFileXML.Trim() + ".xml";
if (File.Exists(m_XmlTextAssetPath))
{
r = XmlSupport.Deserialize <Ranking>(strFileXML);
}
a.nome = nomeSave.text;
a.ponto = Convert.ToInt32(pontosSave.text);
r.players.Add(a);
XmlSupport.Serialize <Ranking>(strFileXML, r);
View();
}
public void UpdateFromPlayerInfo(DetailedPlayerInfo playerInfo)
{
UpdateFromPlayerInfo((PlayerInfoBase)playerInfo);
IsReferee = playerInfo.IsReferee;
IPAddress = Regex.Replace(playerInfo.IPAddress, @":\d+", string.Empty, RegexOptions.Compiled);
OnlineRights = playerInfo.OnlineRights;
Language = playerInfo.Language;
PlayerRanking worldRanking = playerInfo.LadderStats.PlayerRankings.Find(ranking => ranking.Path == "World");
if (worldRanking != null)
{
LadderRanking = worldRanking.Ranking;
}
DetailMode |= PlayerSettingsDetailMode.DetailedPlayerInfo;
}
private void Callbacks_PlayerConnect(object sender, PlayerConnectEventArgs e)
{
RunCatchLog(() =>
{
DetailedPlayerInfo detailedPlayerInfo = GetDetailedPlayerInfo(e.Login);
if (detailedPlayerInfo == null)
{
e.Handled = true;
Context.RPCClient.Methods.Kick(e.Login, "TMSPS couldn't determine your player information, try reconnecting!");
return;
}
NicknameResolverFactory.Instance.Set(e.Login, detailedPlayerInfo.NickName);
if (detailedPlayerInfo.NickName.IsNullOrTimmedEmpty())
{
Context.RPCClient.Methods.Kick(e.Login, "Please provide a nickname!");
e.Handled = true;
return;
}
if (Settings.EnableJoinMessage)
{
string nation = "Unknown";
List <string> pathParts = new List <string>(detailedPlayerInfo.Path.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries));
if (pathParts.Count > 1)
{
nation = string.Join(" > ", pathParts.ToArray(), 1, pathParts.Count - 1);
}
int ladderRank = -1;
PlayerRanking worldRanking = detailedPlayerInfo.LadderStats.PlayerRankings.Find(ranking => ranking.Path == "World");
if (worldRanking != null)
{
ladderRank = worldRanking.Ranking;
}
SendFormattedMessage(Settings.JoinMessage, "Nickname", StripTMColorsAndFormatting(detailedPlayerInfo.NickName), "Nation", nation, "Ladder", ladderRank.ToString(Context.Culture));
}
}, "Error in Callbacks_PlayerConnect Method.", true);
}
public static async Task AddPlayerRanking(Player returnedPlayer, IRankingRepository rankingRepository, IPlayerRepository playerRepository)
{
if (await rankingRepository.GetByPlayerIdAsync(returnedPlayer.PlayerId) != null)
{
PlayerRanking playerRankingToDelete = await rankingRepository.GetByPlayerIdAsync(returnedPlayer.PlayerId);
await rankingRepository.DeleteAsync(playerRankingToDelete);
Console.Write("Previous Ranking Deleted");
}
PlayerRanking playerRankingToAdd = new PlayerRanking();
playerRankingToAdd.PlayerId = returnedPlayer.PlayerId;
IEnumerable <PlayerRanking> allPlayerRanks = await rankingRepository.ListAllAsync();
IEnumerable <Player> allPlayers = await playerRepository.ListAllAsync();
if (allPlayerRanks.Count() > 0)
{
var highestRankedPlayer = allPlayerRanks.Max(x => x.PlayerRank);
var highestPprPlayer = allPlayerRanks.Max(x => x.PprRank);
var highestDynastyPlayer = allPlayerRanks.Max(x => x.DynastyRank);
playerRankingToAdd.PlayerRank = highestRankedPlayer + 1;
playerRankingToAdd.PprRank = highestPprPlayer + 1;
playerRankingToAdd.DynastyRank = highestDynastyPlayer + 1;
CalculatePlayerRanking(returnedPlayer, allPlayerRanks, allPlayers, playerRankingToAdd);
}
else
{
playerRankingToAdd.PlayerRank = 1;
playerRankingToAdd.PosRank = 1;
playerRankingToAdd.PprRank = 1;
playerRankingToAdd.PprPosRank = 1;
playerRankingToAdd.DynastyRank = 1;
playerRankingToAdd.DynastyPosRank = 1;
}
playerRankingToAdd.TestUserProfileId = 2025;
playerRankingToAdd.isDefault = true;
await rankingRepository.AddAsync(playerRankingToAdd);
}
void LoadRanking()
{
if (File.Exists(Application.persistentDataPath + "/playerRanking.txt"))
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/playerRanking.txt", FileMode.Open);
PlayerRanking playerData = (PlayerRanking)binaryFormatter.Deserialize(file);
file.Close();
rankaroo = playerData;
}
else
{
rankaroo = new PlayerRanking();
rankaroo.names = new List <string>();
rankaroo.weaponNames = new List <string>();
rankaroo.weaponAttacks = new List <int>();
rankaroo.timeCompletes = new List <float>();
}
}
public IActionResult Leaderboard()
{
var leaderBoardViewModel = new LeaderBoardViewModel();
//List<int?> profiles = _prestigeScoreRepository.FindAll().Select(p => p.ProfileId).Distinct().ToList();
var innerJoin = _prestigeScoreRepository.FindAll()
.Join(_profileRepository.FindAll(),
playerScore => playerScore.ProfileId,
playerProfile => playerProfile.Id,
(playerScore, playerProfile) => new
{
profileName = playerProfile.ProfileName,
pointsEarned = playerScore.PointsEarned,
totalScore = playerScore.Score,
source = playerScore.Source,
createDate = playerScore.CreatedDate
}).GroupBy(p => new { p.profileName, p.source }).Select(group => new
{
group.Key.profileName,
score = group.Max(d => d.totalScore)
}).OrderByDescending(s => s.score).Select(s => new
{
s.profileName,
s.score
}).GroupBy(p => p.profileName).Select(s => new
{
profileName = s.Key,
score = s.Max(m => m.score)
}).OrderByDescending(o => o.score).ToList();
List <PlayerRanking> playerRankings = new List <PlayerRanking>();
foreach (var item in innerJoin)
{
PlayerRanking ranking = new PlayerRanking();
ranking.ProfileName = item.profileName;
ranking.Score = item.score;
playerRankings.Add(ranking);
}
return(View(playerRankings));
}
public void SaveRanking()
{
Debug.Log("SaveRanking");
LoadRanking();
//int length = rankaroo.timeCompletes.Count;
//bool worthSaving = false;
//if (length >= 3)
//{
// for (int i = 0; i < length; i++)
// {
// Debug.Log(rankaroo.weaponAttacks[i]);
// if (rankaroo.weaponAttacks[i] < player.Weapon.Attack)
// {
// worthSaving = true;
// }
// }
//}
//else
//{
// worthSaving = true;
//}
Debug.Log("Yeah we save this");
rankaroo.test = "";
rankaroo.names.Add(player.Name);
rankaroo.weaponNames.Add(player.Weapon.Name + " of " + player.Weapon.Modifier);
rankaroo.weaponAttacks.Add(player.Weapon.Attack);
rankaroo.timeCompletes.Add(Time.time - player.TimeStart);
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream file = File.Open(Application.persistentDataPath + "/playerRanking.txt", FileMode.OpenOrCreate);
PlayerRanking playerData = rankaroo;
binaryFormatter.Serialize(file, playerData);
file.Close();
}
private IEnumerable <PlayerRanking> DeterminePlayerRankings()
{
var calculators = new List <IPlayerRankingCalculator>()
{
new PlayerTrueSkillCalculator(),
new TimMahyFoosballCalculator(),
new WinsPercentageCalculator(),
new PlayerDuelEloFideCalculator(),
new PlayerDuelEloGaussianCalculator(),
new LongestWinningStreakCalculator(),
new GlickoCalculator()
};
foreach (var calculator in calculators)
{
var ranking = new PlayerRanking()
{
Name = calculator.Name,
Ranking = GetRankingResults(calculator)
};
yield return(ranking);
}
}
public void Delete(PlayerRanking entityToDelete)
{
_repository.Delete(entityToDelete);
}
public void Update(PlayerRanking entityToUpdate)
{
_repository.Update(entityToUpdate);
}
private void Callbacks_PlayerConnect(object sender, PlayerConnectEventArgs e)
{
if (e.Handled)
{
Logger.Debug(string.Format("Callbacks_PlayerConnect method skipped for login: {0}. Eventargs stated: Already handled", e.Login));
return;
}
RunCatchLog(() =>
{
PlayerSettings playerSettings = GetPlayerSettings(e.Login);
if (playerSettings == null)
{
Logger.Debug(string.Format("Could not get PlayerSettings for login: {0}", e.Login));
return;
}
int ladderRanking;
if (!playerSettings.DetailMode.HasDetailedPlayerInfo())
{
DetailedPlayerInfo detailedPlayerInfo = GetDetailedPlayerInfo(e.Login);
if (detailedPlayerInfo == null)
{
Logger.Debug(string.Format("Could not get DetailedPlayerInfo for login: {0}", e.Login));
return;
}
PlayerRanking worldRanking = detailedPlayerInfo.LadderStats.PlayerRankings.Find(ranking => ranking.Path == "World");
if (worldRanking == null)
{
Logger.Debug(string.Format("Could not find World-Ranking for login: {0}", e.Login));
return;
}
ladderRanking = worldRanking.Ranking;
}
else
{
ladderRanking = playerSettings.LadderRanking;
}
if (ladderRanking != -1)
{
return;
}
GenericResponse <bool> kickResponse = Context.RPCClient.Methods.Kick(e.Login, Settings.PersonalKickMessage);
if (kickResponse.Erroneous)
{
Logger.Debug(string.Format("Could not kick login: {0}. Reason: {1}({2})", e.Login, kickResponse.Fault.FaultMessage, kickResponse.Fault.FaultCode));
return;
}
SendFormattedMessage(Settings.PublicKickMessage, "Nickname", StripTMColorsAndFormatting(playerSettings.NickName));
e.Handled = true;
}, "Error in Callbacks_PlayerConnect Method.", true);
}
private static void CalculatePlayerRanking(Player returnedPlayer, IEnumerable <PlayerRanking> allPlayerRankings, IEnumerable <Player> allPlayers, PlayerRanking playerRankingToAdd)
{
List <PlayerRanking> allPosRanks = new List <PlayerRanking>();
foreach (PlayerRanking p in allPlayerRankings)
{
var idToCheck = p.PlayerId;
Player playerToCheck = allPlayers.First(x => x.PlayerId == idToCheck);
if (playerToCheck.PlayerPos == returnedPlayer.PlayerPos)
{
allPosRanks.Add(p);
}
}
if (allPosRanks.Count() > 0)
{
var highestPosRank = allPosRanks.Max(x => x.PosRank);
var highestPprPosRank = allPosRanks.Max(x => x.PprPosRank);
var highestDynastyPosRank = allPosRanks.Max(x => x.DynastyPosRank);
playerRankingToAdd.PosRank = highestPosRank + 1;
playerRankingToAdd.PprPosRank = highestPprPosRank + 1;
playerRankingToAdd.DynastyPosRank = highestDynastyPosRank + 1;
}
else
{
playerRankingToAdd.PosRank = 1;
playerRankingToAdd.PprPosRank = 1;
playerRankingToAdd.DynastyPosRank = 1;
}
}
//public PlayerRanking GetByName(string PlayerRankingName)
//{
//Pass in WHERE clause as a lambda here
// List<PlayerRanking> _PlayerRankingsWithName = _repository.Get( e => e.Name == PlayerRankingName).ToList();
// return
//}
public void Insert(PlayerRanking entity)
{
_repository.Insert(entity);
}
private static int SortPlayerRankings(PlayerRanking player1, PlayerRanking player2)
{
return(player2.score.CompareTo(player1.score));
}
public void UpdateRankings(FixtureMatchVM fixtureMatch)
{
int nPositions = _context.Divisions.FirstOrDefault(d => d.ID == fixtureMatch.Fixture.DivisionID).PositionNo;
Fixture fixture = fixtureMatch.Fixture;
TeamRanking teamRankingHome = new TeamRanking();
var teamRankingHomeToUpdate = _context.TeamRankings.FirstOrDefault(d => d.TeamID == fixture.HomeTeamID && d.SeasonID == fixture.SeasonID && d.DivisionID == fixture.DivisionID);
TeamRanking teamRankingAway = new TeamRanking();
var teamRankingAwayToUpdate = _context.TeamRankings.FirstOrDefault(d => d.TeamID == fixture.AwayTeamID && d.SeasonID == fixture.SeasonID && d.DivisionID == fixture.DivisionID);
if (teamRankingHomeToUpdate == null)
{
teamRankingHome.TeamID = fixture.HomeTeamID;
teamRankingHome.DivisionID = fixture.DivisionID;
teamRankingHome.SeasonID = fixture.SeasonID;
teamRankingHome.Points = (double)(fixture.HomeTeamScore + fixture.HomeTeamBonus);
teamRankingHome.Won = (fixture.HomeTeamScore > fixture.AwayTeamScore) ? 1 : 0;
teamRankingHome.Lost = (fixture.HomeTeamScore < fixture.AwayTeamScore) ? 1 : 0;
teamRankingHome.Played = 1;
_context.Add(teamRankingHome);
_context.SaveChanges();
}
else
{
teamRankingHome = teamRankingHomeToUpdate;
teamRankingHome.Points += (double)(fixture.HomeTeamScore + fixture.HomeTeamBonus);
teamRankingHome.Won += (fixture.HomeTeamScore > fixture.AwayTeamScore) ? 1 : 0;
teamRankingHome.Lost += (fixture.HomeTeamScore < fixture.AwayTeamScore) ? 1 : 0;
teamRankingHome.Played += 1;
_context.Update(teamRankingHome);
_context.SaveChanges();
}
if (teamRankingAwayToUpdate == null)
{
teamRankingAway.TeamID = fixture.AwayTeamID;
teamRankingAway.DivisionID = fixture.DivisionID;
teamRankingAway.SeasonID = fixture.SeasonID;
teamRankingAway.Points = (double)(fixture.AwayTeamScore + fixture.AwayTeamBonus);
teamRankingAway.Won = (fixture.HomeTeamScore < fixture.AwayTeamScore) ? 1 : 0;
teamRankingAway.Lost = (fixture.HomeTeamScore > fixture.AwayTeamScore) ? 1 : 0;
teamRankingAway.Played = 1;
_context.Add(teamRankingAway);
_context.SaveChanges();
}
else
{
teamRankingAway = teamRankingAwayToUpdate;
teamRankingAway.Points += (double)(fixture.AwayTeamScore + fixture.AwayTeamBonus);
teamRankingAway.Won += (fixture.HomeTeamScore < fixture.AwayTeamScore) ? 1 : 0;
teamRankingAway.Lost += (fixture.HomeTeamScore > fixture.AwayTeamScore) ? 1 : 0;
teamRankingAway.Played += 1;
_context.Update(teamRankingAway);
_context.SaveChanges();
}
//Loop trough the matches to update the rankings
foreach (Match match in fixtureMatch.Matches)
{
if (match.HomePlayerID != 1)
{
//Add statistics for home player
PlayerRanking playerRankingHome = new PlayerRanking();
var playerRankingHomeToUpdate = _context.PlayerRankings.FirstOrDefault(d => d.PlayerID == match.HomePlayerID && d.SeasonID == fixture.SeasonID && d.DivisionID == fixture.DivisionID);
if (playerRankingHomeToUpdate == null)
{
playerRankingHome.TotalPositions = (int)match.PositionID;
playerRankingHome.PlayerID = match.HomePlayerID;
playerRankingHome.SeasonID = fixture.SeasonID;
playerRankingHome.DivisionID = fixture.DivisionID;
playerRankingHome.Played = 1;
if (match.HomePlayerScore > match.AwayPlayerScore)
{
playerRankingHome.WonMatches = 1;
playerRankingHome.LostMatches = 0;
}
else
{
playerRankingHome.WonMatches = 0;
playerRankingHome.LostMatches = 1;
}
playerRankingHome.WonGames = (short)match.HomePlayerScore;
playerRankingHome.LostGames = (short)match.AwayPlayerScore;
playerRankingHome.Points = RankPlayer.CalcPoints(match.Position.Name, (short)match.HomePlayerScore, (short)match.AwayPlayerScore, ResultFor.Home);
playerRankingHome.Average = playerRankingHome.Points / playerRankingHome.Played;
_context.Add(playerRankingHome);
}
else
{
playerRankingHome = playerRankingHomeToUpdate;
playerRankingHome.Played += 1;
playerRankingHome.TotalPositions += (int)match.PositionID;
if (match.HomePlayerScore > match.AwayPlayerScore)
{
playerRankingHome.WonMatches += 1;
}
else
{
playerRankingHome.LostMatches += 1;
}
playerRankingHome.WonGames += (short)match.HomePlayerScore;
playerRankingHome.LostGames += (short)match.AwayPlayerScore;
playerRankingHome.Points += RankPlayer.CalcPoints(match.Position.Name, (short)match.HomePlayerScore, (short)match.AwayPlayerScore, ResultFor.Home);
playerRankingHome.Average = playerRankingHome.Points / playerRankingHome.Played;
_context.Update(playerRankingHome);
}
}
if (match.AwayPlayerID != 1)
{
//Add statistics for away player
PlayerRanking playerRankingAway = new PlayerRanking();
var playerRankingAwayToUpdate = _context.PlayerRankings.FirstOrDefault(d => d.PlayerID == match.AwayPlayerID && d.SeasonID == fixture.SeasonID && d.DivisionID == fixture.DivisionID);
if (playerRankingAwayToUpdate == null)
{
playerRankingAway.PlayerID = match.AwayPlayerID;
playerRankingAway.SeasonID = fixture.SeasonID;
playerRankingAway.DivisionID = fixture.DivisionID;
playerRankingAway.Played = 1;
playerRankingAway.TotalPositions = (int)match.PositionID;
if (match.HomePlayerScore < match.AwayPlayerScore)
{
playerRankingAway.WonMatches = 1;
playerRankingAway.LostMatches = 0;
}
else
{
playerRankingAway.WonMatches = 0;
playerRankingAway.LostMatches = 1;
}
playerRankingAway.WonGames = (short)match.AwayPlayerScore;
playerRankingAway.LostGames = (short)match.HomePlayerScore;
playerRankingAway.Points = RankPlayer.CalcPoints(match.Position.Name, (short)match.HomePlayerScore, (short)match.AwayPlayerScore, ResultFor.Away);
playerRankingAway.Average = playerRankingAway.Points / playerRankingAway.Played;
_context.Add(playerRankingAway);
}
else
{
playerRankingAway = playerRankingAwayToUpdate;
playerRankingAway.Played += 1;
playerRankingAway.TotalPositions += (int)match.PositionID;
if (match.HomePlayerScore < match.AwayPlayerScore)
{
playerRankingAway.WonMatches += 1;
}
else
{
playerRankingAway.LostMatches += 1;
}
playerRankingAway.WonGames += (short)match.AwayPlayerScore;
playerRankingAway.LostGames += (short)match.HomePlayerScore;
playerRankingAway.Points += RankPlayer.CalcPoints(match.Position.Name, (short)match.HomePlayerScore, (short)match.AwayPlayerScore, ResultFor.Away);
playerRankingAway.Average = playerRankingAway.Points / playerRankingAway.Played;
_context.Update(playerRankingAway);
}
}
}
_context.SaveChanges();
}
