private void SetStandings(TournamentMain tourn)
{
objTournMain = new TournamentMain();
objTournMain = tourn;
Title += objTournMain.Name;
Utilities.CalculatePlayerScores(ref objTournMain);
List <TournamentMainPlayer> lstPlayerStandings = new List <TournamentMainPlayer>();
foreach (TournamentMainPlayer player in objTournMain.Players.OrderBy(obj => obj.Rank).ToList())
{
//Separating out as to not tempt fate and inadvertently change any data unintentionally
TournamentMainPlayer tmpPlayer = new TournamentMainPlayer();
tmpPlayer.Rank = player.Rank;
tmpPlayer.PlayerName = player.PlayerName;
tmpPlayer.Score = player.Score;
tmpPlayer.MOV = player.MOV;
tmpPlayer.SOS = player.SOS;
if (!player.Active)
{
tmpPlayer.PlayerName += " (D)";
}
lstPlayerStandings.Add(tmpPlayer);
}
tournamentStandingsListView.ItemsSource = lstPlayerStandings;
}
//Set the copy of the player
public PlayerToTournamentMainPlayer_ViewModel(Player player, int intTournamentId, int intRow, TournamentMainPlayer tournamentPlayer = null)
{
TournamentMainPlayer = new TournamentMainPlayer();
if (tournamentPlayer is null)
{
TournamentMainPlayer.TournmentId = intTournamentId;
TournamentMainPlayer.PlayerId = player.Id;
TournamentMainPlayer.PlayerName = player.Name;
TournamentMainPlayer.Active = player.Active;
}
else
{
TournamentMainPlayer = tournamentPlayer;
}
if (intRow % 2 == 0)
{
RowBackgroundColor = Color.LightGray;
}
else
{
RowBackgroundColor = Color.Transparent;
}
}
//Set the copy of the player
public PlayerToTournamentMainPlayer_ViewModel(Player player, int intTournamentId, TournamentMainPlayer tournamentPlayer = null)
{
TournamentMainPlayer = new TournamentMainPlayer();
if (tournamentPlayer is null)
{
TournamentMainPlayer.TournamentId = intTournamentId;
TournamentMainPlayer.PlayerId = player.Id;
TournamentMainPlayer.PlayerName = player.Name;
TournamentMainPlayer.Active = player.Active;
}
else
{
TournamentMainPlayer = tournamentPlayer;
}
}
//Opening / OnAppearing
protected override void OnAppearing()
{
this.IsBusy = true;
this.BarBackgroundColor = Color.Default;
this.BarTextColor = Color.Default;
base.OnAppearing();
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
objTournMain = new TournamentMain();
objTournMain = conn.GetWithChildren <TournamentMain>(intTournID, true);
Title = objTournMain.Name;
intDefaultRoundLength = objTournMain.RoundTimeLength;
UpdatePlayerList(conn);
//Get full list of players
List <Player> lstPlayers = conn.Query <Player>("SELECT * FROM Player WHERE (Active = 1 AND DateDeleted IS NULL) OR Id IN (" + objTournMain.ActivePlayersList() + ") ORDER BY Name");
//Get list of currently active players in tournament
string[] arrActivePlayers = objTournMain.ActivePlayersList().Split(',');
//Set using the ViewModel version. This allows being able to manipulate back and forth across the class properties, while displaying as intended on the GUI
//while also ensuring none of the goings ons of the properties touching each other don't occur without this specific view model (such as the SQL table updates)
lstViewPlayers = new ObservableCollection <PlayerToTournamentMainPlayer_ViewModel>();
TournamentMainPlayer tmpTournamentMainPlayer = null;
foreach (Player player in lstPlayers)
{
player.Active = false;
if (arrActivePlayers.Contains <string>(player.Id.ToString()))
{
player.Active = true;
}
//Set the tournament player equivalent
tmpTournamentMainPlayer = null;
foreach (TournamentMainPlayer tournamentPlayer in objTournMain.Players)
{
if (tournamentPlayer.PlayerId == player.Id)
{
tmpTournamentMainPlayer = tournamentPlayer;
break;
}
}
lstViewPlayers.Add(new PlayerToTournamentMainPlayer_ViewModel(player, intTournID, tmpTournamentMainPlayer));
}
playersListView.ItemsSource = lstViewPlayers;
}
//Remove all the "Round" tabs and then repopulate them
for (int index = this.Children.Count - 1; index > 0; index--)
{
if (index > 0)
{
this.Children.RemoveAt(index);
}
}
//Add each round as tabs
foreach (TournamentMainRound round in objTournMain.Rounds)
{
Children.Add(new Tournaments_RoundInfo(this, "Rd " + round.Number, round.Id, objTournMain.Rounds.Count));
//Help indicate that we're no longer in "Swiss" mode
if (!round.Swiss)
{
this.BarBackgroundColor = Color.LightGray;
this.BarTextColor = Color.Black;
}
}
//Try to shorten "players" if the tab count gets higher
if (objTournMain.Rounds.Count > 4)
{
mainPlayerPage.Title = "Plyrs";
}
else
{
mainPlayerPage.Title = "Players";
}
//Select the last tab
if (Children.Count > 0)
{
this.SelectedItem = Children[Children.Count - 1];
}
this.IsBusy = false;
}
private bool SetupSwissPlayers(ref List <TournamentMainPlayer> lstActiveTournamentPlayers, ref List <TournamentMainPlayer> lstActiveTournamentPlayers_Byes, int intAttempts = 0)
{
//Grab list of currently active players in the tournament
Dictionary <int, List <TournamentMainPlayer> > dctActiveTournamentPlayerScores = new Dictionary <int, List <TournamentMainPlayer> >();
foreach (TournamentMainPlayer player in objTournMain.Players)
{
if (player.Active)
{
TournamentMainPlayer roundPlayer = new TournamentMainPlayer();
roundPlayer.PlayerId = player.PlayerId;
roundPlayer.Score = player.Score;
roundPlayer.OpponentIds = player.OpponentIds;
if (!player.Bye)
{
lstActiveTournamentPlayers.Add(roundPlayer);
}
else
{
lstActiveTournamentPlayers_Byes.Add(roundPlayer);
player.Bye = false; //No longer has a Bye for the next round
player.ByeCount++;
}
}
}
if (objTournMain.Rounds.Count == 0)
{
//First round, completely random player pairings
lstActiveTournamentPlayers.Shuffle();
}
else
{
//Subsequent rounds, group up players with same win count as much as possible and randomize
dctActiveTournamentPlayerScores = new Dictionary <int, List <TournamentMainPlayer> >();
for (int i = objTournMain.Rounds.Count; i >= 0; i--)
{
dctActiveTournamentPlayerScores.Add(i, new List <TournamentMainPlayer>());
foreach (TournamentMainPlayer activePlayer in lstActiveTournamentPlayers)
{
if (i == activePlayer.Score)
{
dctActiveTournamentPlayerScores[i].Add(activePlayer);
}
}
dctActiveTournamentPlayerScores[i].Shuffle(); //Shuffle all the players in each win bracket
}
//Clear out the active list, then go down the list and re-add them back in.
lstActiveTournamentPlayers.Clear();
for (int i = objTournMain.Rounds.Count; i >= 0; i--)
{
if (dctActiveTournamentPlayerScores.ContainsKey(i))
{
foreach (TournamentMainPlayer activePlayer in dctActiveTournamentPlayerScores[i])
{
lstActiveTournamentPlayers.Add(activePlayer);
}
}
}
//If odd number of players, the last in the list will get a Bye
//Get the lowest ranked player that hasn't had a bye already
if (lstActiveTournamentPlayers.Count % 2 != 0)
{
foreach (TournamentMainPlayer player in objTournMain.Players.OrderByDescending(obj => obj.Rank).ToList())
{
if (player.ByeCount == 0)
{
for (int i = lstActiveTournamentPlayers.Count - 1; i > 0; i--)
{
if (lstActiveTournamentPlayers[i].PlayerId == player.PlayerId)
{
TournamentMainPlayer roundPlayer = lstActiveTournamentPlayers[i];
lstActiveTournamentPlayers.RemoveAt(i);
lstActiveTournamentPlayers.Add(roundPlayer);
break;
}
}
break;
}
}
}
//Triple check to make sure no one is playing someone that they have already.
//Reshuffle as necessary, multiple times (perhaps the tournament decides to keep going for whatever reason)
if (intAttempts < 100)
{
bool bFailMatchup = false;
int intCount = 1;
TournamentMainPlayer tmpPlayer1 = new TournamentMainPlayer();
foreach (TournamentMainPlayer player in lstActiveTournamentPlayers)
{
//Check every even player to see if they have already been paired up with the player before them (as they will be the ones paired up to went forwarded to the round table)
if (intCount % 2 == 0)
{
if (player.OpponentIds.Contains(tmpPlayer1.Id))
{
bFailMatchup = true;
break;
}
}
else
{
tmpPlayer1 = player;
}
intCount++;
}
if (bFailMatchup)
{
lstActiveTournamentPlayers = new List <TournamentMainPlayer>();
lstActiveTournamentPlayers_Byes = new List <TournamentMainPlayer>();
SetupSwissPlayers(ref lstActiveTournamentPlayers, ref lstActiveTournamentPlayers_Byes, intAttempts++);
}
}
}
return(true);
}
public void GetAllTournamentInfo(SqlConnection sqlConn, ref List <TournamentMain> returnTournaments)
{
//Grab all the players associated with this tournament
foreach (TournamentMain newTournament in returnTournaments)
{
using (SqlCommand sqlCmd = new SqlCommand("dbo.spTournamentsPlayers_GET", sqlConn))
{
sqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlCmd.Parameters.AddWithValue("@TournamentId", newTournament.Id);
using (SqlDataReader sqlReader = sqlCmd.ExecuteReader())
{
while (sqlReader.Read())
{
TournamentMainPlayer player = new TournamentMainPlayer
{
Id = sqlReader.GetInt32(sqlReader.GetOrdinal("Id")),
TournamentId = sqlReader.GetInt32(sqlReader.GetOrdinal("TournamentId")),
PlayerId = sqlReader.GetInt32(sqlReader.GetOrdinal("PlayerId")),
OpponentIdsBlobbed = sqlReader.GetString(sqlReader.GetOrdinal("OpponentIds")),
PlayerName = sqlReader.GetString(sqlReader.GetOrdinal("PlayerName")),
Active = sqlReader.GetBoolean(sqlReader.GetOrdinal("Active")),
Bye = sqlReader.GetBoolean(sqlReader.GetOrdinal("Bye")),
ByeCount = sqlReader.GetInt32(sqlReader.GetOrdinal("ByeCount")),
RoundsPlayed = sqlReader.GetInt32(sqlReader.GetOrdinal("RoundsPlayed")),
Rank = sqlReader.GetInt32(sqlReader.GetOrdinal("Rank")),
Score = sqlReader.GetInt32(sqlReader.GetOrdinal("Score")),
MOV = sqlReader.GetInt32(sqlReader.GetOrdinal("MOV")),
SOS = sqlReader.GetDecimal(sqlReader.GetOrdinal("SOS")),
API_UserAccountId = sqlReader.GetInt32(sqlReader.GetOrdinal("UserAccountId"))
};
newTournament.Players.Add(player);
}
}
}
using (SqlCommand sqlCmd = new SqlCommand("dbo.spTournamentsRounds_GET", sqlConn))
{
sqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlCmd.Parameters.AddWithValue("@TournamentId", newTournament.Id);
using (SqlDataReader sqlReader = sqlCmd.ExecuteReader())
{
while (sqlReader.Read())
{
TournamentMainRound round = new TournamentMainRound
{
Id = sqlReader.GetInt32(sqlReader.GetOrdinal("Id")),
TournamentId = sqlReader.GetInt32(sqlReader.GetOrdinal("TournamentId")),
Number = sqlReader.GetInt32(sqlReader.GetOrdinal("Number")),
Swiss = sqlReader.GetBoolean(sqlReader.GetOrdinal("Swiss"))
};
if (!sqlReader.IsDBNull(sqlReader.GetOrdinal("RoundTimeEnd")))
{
round.RoundTimeEnd = sqlReader.GetDateTime(sqlReader.GetOrdinal("RoundTimeEnd"));
}
newTournament.Rounds.Add(round);
}
}
}
foreach (TournamentMainRound round in newTournament.Rounds)
{
using (SqlCommand sqlCmd = new SqlCommand("dbo.spTournamentsRoundsTables_GET", sqlConn))
{
sqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlCmd.Parameters.AddWithValue("@RoundId", round.Id);
using (SqlDataReader sqlReader = sqlCmd.ExecuteReader())
{
while (sqlReader.Read())
{
TournamentMainRoundTable table = new TournamentMainRoundTable
{
Id = sqlReader.GetInt32(sqlReader.GetOrdinal("Id")),
RoundId = sqlReader.GetInt32(sqlReader.GetOrdinal("RoundId")),
Number = sqlReader.GetInt32(sqlReader.GetOrdinal("Number")),
TableName = sqlReader.GetString(sqlReader.GetOrdinal("TableName")),
ScoreTied = sqlReader.GetBoolean(sqlReader.GetOrdinal("ScoreTied")),
Bye = sqlReader.GetBoolean(sqlReader.GetOrdinal("Bye")),
Player1Id = sqlReader.GetInt32(sqlReader.GetOrdinal("Player1Id")),
Player1Name = sqlReader.GetString(sqlReader.GetOrdinal("Player1Name")),
Player1Winner = sqlReader.GetBoolean(sqlReader.GetOrdinal("Player1Winner")),
Player1Score = sqlReader.GetInt32(sqlReader.GetOrdinal("Player1Score")),
Player2Id = sqlReader.GetInt32(sqlReader.GetOrdinal("Player2Id")),
Player2Name = sqlReader.GetString(sqlReader.GetOrdinal("Player2Name")),
Player2Winner = sqlReader.GetBoolean(sqlReader.GetOrdinal("Player2Winner")),
Player2Score = sqlReader.GetInt32(sqlReader.GetOrdinal("Player2Score"))
};
round.Tables.Add(table);
}
}
}
}
}
}
public static void CalculatePlayerScores(ref TournamentMain objTournMain)
{
//All the players in the tournament should be included, regardless of being currently active in the tournament or not.
int intScoreDiff = 0;
bool blnWinner = false;
Dictionary <int, TournamentMainPlayer> dctPlayers = new Dictionary <int, TournamentMainPlayer>();
//Reset and calculate each player's score
foreach (TournamentMainPlayer player in objTournMain.Players)
{
if (!dctPlayers.ContainsKey(player.PlayerId))
{
dctPlayers.Add(player.PlayerId, new TournamentMainPlayer());
}
player.MOV = 0;
player.RoundsPlayed = 0;
player.Score = 0;
player.SOS = 0;
player.ByeCount = 0;
player.OpponentIds = new List <int>();
//Go through each round, find their table and calculate the Margin of Victory (MOV) score
foreach (TournamentMainRound round in objTournMain.Rounds)
{
foreach (TournamentMainRoundTable table in round.Tables)
{
if ((table.Player1Id == player.PlayerId || table.Player2Id == player.PlayerId) && (table.Player1Winner || table.Player2Winner))
{
player.RoundsPlayed++;
blnWinner = false;
//Keep track of all the opponents faced for each player
if (table.Player1Id == player.PlayerId)
{
if (table.Player2Id > 0)
{
player.OpponentIds.Add(table.Player2Id);
}
else if (table.Bye)
{
player.ByeCount++;
}
}
else
{
player.OpponentIds.Add(table.Player1Id);
}
//Set the table's score difference and if player is the winner
if (table.Player1Winner)
{
intScoreDiff = table.Player1Score - table.Player2Score;
if (player.PlayerId == table.Player1Id)
{
blnWinner = true;
}
}
else if (table.Player2Winner)
{
intScoreDiff = table.Player2Score - table.Player1Score;
if (player.PlayerId == table.Player2Id)
{
blnWinner = true;
}
}
//Set points if score tied for the table
if (table.ScoreTied)
{
player.MOV += objTournMain.MaxPoints;
}
//Set score and MOV
if (blnWinner)
{
player.Score++;
if (!table.ScoreTied)
{
player.MOV += (intScoreDiff + objTournMain.MaxPoints);
}
}
else
{
if (!table.ScoreTied)
{
player.MOV += (objTournMain.MaxPoints - intScoreDiff);
}
}
break;
}
}
}
//Set player dictionary for quick access here soon
dctPlayers[player.PlayerId] = player;
}
//Now calculate the Strength of Schedule (SOS)
if (objTournMain.Rounds.Count > 0)
{
foreach (TournamentMainPlayer player in objTournMain.Players)
{
if (player.RoundsPlayed == 0)
{
continue;
}
decimal decSoS = 0;
foreach (int opponentId in player.OpponentIds)
{
if (dctPlayers.ContainsKey(opponentId))
{
TournamentMainPlayer opponent = dctPlayers[opponentId];
if (opponent.RoundsPlayed == 0)
{
continue;
}
decSoS += Decimal.Divide(opponent.Score, opponent.RoundsPlayed);
}
}
decSoS /= player.RoundsPlayed;
player.SOS = Math.Round(decSoS, 2);
}
}
//Determine standings/rank
List <TournamentMainPlayer> lstStandings = GetStandings(objTournMain);
int intRank = 1;
foreach (TournamentMainPlayer standingPlayer in lstStandings)
{
foreach (TournamentMainPlayer mainPlayer in objTournMain.Players)
{
if (standingPlayer.PlayerId == mainPlayer.PlayerId)
{
mainPlayer.Rank = intRank;
break;
}
}
intRank++;
}
}
//Opening
protected override void OnAppearing()
{
base.OnAppearing();
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
objTournMain = new TournamentMain();
objTournMain = conn.GetWithChildren <TournamentMain>(intTournID, true);
Title = objTournMain.Name;
UpdatePlayerList(conn);
//Get full list of players
List <Player> lstPlayers = conn.Query <Player>("SELECT * FROM Player WHERE (Active = 1 AND DateDeleted IS NULL) OR Id IN (" + objTournMain.ActivePlayersList() + ")");
//Get list of currently active players in tournament
string[] arrActivePlayers = objTournMain.ActivePlayersList().Split(',');
//Set using the ViewModel version. This allows being able to manipulate back and forth across the class properties, while displaying as intended on the GUI
//while also ensuring none of the goings ons of the properties touching each other don't occur without this specific view model (such as the SQL table updates)
int intRow = 0;
lstViewPlayers = new ObservableCollection <PlayerToTournamentMainPlayer_ViewModel>();
TournamentMainPlayer tmpTournamentMainPlayer = null;
foreach (Player player in lstPlayers)
{
player.Active = false;
if (arrActivePlayers.Contains <string>(player.Id.ToString()))
{
player.Active = true;
}
intRow++;
//Set the tournament player equivalent
tmpTournamentMainPlayer = null;
foreach (TournamentMainPlayer tournamentPlayer in objTournMain.Players)
{
if (tournamentPlayer.PlayerId == player.Id)
{
tmpTournamentMainPlayer = tournamentPlayer;
break;
}
}
lstViewPlayers.Add(new PlayerToTournamentMainPlayer_ViewModel(player, intTournID, intRow, tmpTournamentMainPlayer));
}
playersListView.ItemsSource = lstViewPlayers;
}
//Remove all the "Round" tabs and then repopulate them
for (int index = this.Children.Count - 1; index > 0; index--)
{
if (index > 0)
{
this.Children.RemoveAt(index);
}
}
//Add each round as tabs
foreach (TournamentMainRound round in objTournMain.Rounds)
{
Children.Add(new Tournaments_RoundInfo("Rd " + round.Number, round.Id, objTournMain.Rounds.Count));
}
//Remove option to delete round if there are no rounds
if (objTournMain.Rounds.Count == 0)
{
ToolbarItems.Remove(deleteRoundBtn);
}
}
//Start next round
private void startRoundBtn_ToolbarItem_Activated(object sender, EventArgs e)
{
//Make sure we actually have players
if (objTournMain.Players.Count == 0)
{
DisplayAlert("Warning!", "You must add players first to this tournament!", "D'oh!");
return;
}
//Housekeeping with the latest round
if (objTournMain.Rounds.Count > 0)
{
//Grab the latest information before checking the scores and calculating them
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
objTournMain = new TournamentMain();
objTournMain = conn.GetWithChildren <TournamentMain>(intTournID, true);
}
TournamentMainRound latestRound = objTournMain.Rounds[objTournMain.Rounds.Count - 1];
//Before starting a new round, make sure we're not missing any scores
foreach (TournamentMainRoundTable table in latestRound.Tables)
{
if (!table.Player1Winner && !table.Player2Winner)
{
DisplayAlert("Warning!", "Verify that all tables are completed for the current round!", "D'oh!");
return;
}
}
Utilities.CalculatePlayerScores(ref objTournMain);
}
//Grab list of currently active players in the tournament
Dictionary <int, List <TournamentMainPlayer> > dctActiveTournamentPlayerScores = new Dictionary <int, List <TournamentMainPlayer> >();
List <TournamentMainPlayer> lstActiveTournamentPlayers = new List <TournamentMainPlayer>();
List <TournamentMainPlayer> lstActiveTournamentPlayers_Byes = new List <TournamentMainPlayer>();
foreach (TournamentMainPlayer player in objTournMain.Players)
{
if (player.Active)
{
TournamentMainPlayer roundPlayer = new TournamentMainPlayer();
roundPlayer.PlayerId = player.PlayerId;
roundPlayer.Score = player.Score;
if (!player.Bye)
{
lstActiveTournamentPlayers.Add(roundPlayer);
}
else
{
lstActiveTournamentPlayers_Byes.Add(roundPlayer);
player.Bye = false; //No longer has a Bye for the next round
player.ByeCount++;
}
}
}
//Create a new round
TournamentMainRound round = new TournamentMainRound();
round.TournmentId = intTournID;
round.Number = objTournMain.Rounds.Count + 1;
if (objTournMain.Rounds.Count == 0)
{
//First round, completely random player pairings
lstActiveTournamentPlayers.Shuffle();
}
else
{
//Subsequent rounds, group up players with same win count as much as possible and randomize
dctActiveTournamentPlayerScores = new Dictionary <int, List <TournamentMainPlayer> >();
for (int i = objTournMain.Rounds.Count; i >= 0; i--)
{
dctActiveTournamentPlayerScores.Add(i, new List <TournamentMainPlayer>());
foreach (TournamentMainPlayer activePlayer in lstActiveTournamentPlayers)
{
if (i == activePlayer.Score)
{
dctActiveTournamentPlayerScores[i].Add(activePlayer);
}
}
dctActiveTournamentPlayerScores[i].Shuffle(); //Shuffle all the players in each win bracket
}
//Clear out the active list, then go down the list and re-add them back in.
lstActiveTournamentPlayers.Clear();
for (int i = objTournMain.Rounds.Count; i >= 0; i--)
{
if (dctActiveTournamentPlayerScores.ContainsKey(i))
{
foreach (TournamentMainPlayer activePlayer in dctActiveTournamentPlayerScores[i])
{
lstActiveTournamentPlayers.Add(activePlayer);
}
}
}
//If odd number of players, the last in the list will get a Bye
//Get the lowest ranked player that hasn't had a bye already
if (lstActiveTournamentPlayers.Count % 2 != 0)
{
foreach (TournamentMainPlayer player in objTournMain.Players.OrderByDescending(obj => obj.Rank).ToList())
{
if (player.ByeCount == 0)
{
for (int i = lstActiveTournamentPlayers.Count - 1; i > 0; i--)
{
if (lstActiveTournamentPlayers[i].PlayerId == player.PlayerId)
{
TournamentMainPlayer roundPlayer = lstActiveTournamentPlayers[i];
lstActiveTournamentPlayers.RemoveAt(i);
lstActiveTournamentPlayers.Add(roundPlayer);
break;
}
}
break;
}
}
}
}
//Create each table, pair 'em up
TournamentMainRoundTable roundTable = new TournamentMainRoundTable();
foreach (TournamentMainPlayer player in lstActiveTournamentPlayers)
{
if (roundTable.Player1Id != 0 && roundTable.Player2Id != 0)
{
setRoundTableNames(ref roundTable);
round.Tables.Add(roundTable);
roundTable = new TournamentMainRoundTable();
}
if (roundTable.Player1Id == 0)
{
roundTable.Number = round.Tables.Count + 1;
roundTable.Player1Id = player.PlayerId;
}
else if (roundTable.Player2Id == 0)
{
roundTable.Player2Id = player.PlayerId;
}
}
//If the last table of non-manual byes is an odd-man, set table/player as a bye
if (roundTable.Player2Id == 0)
{
roundTable.Bye = true;
roundTable.Player1Score = objTournMain.MaxPoints / 2;
roundTable.Player1Winner = true;
foreach (TournamentMainPlayer player in objTournMain.Players)
{
if (player.Id == roundTable.Player2Id)
{
player.ByeCount++;
break;
}
}
}
setRoundTableNames(ref roundTable);
round.Tables.Add(roundTable);
//If a manual bye (such as first-round byes at a tournament), add these players now
if (lstActiveTournamentPlayers_Byes.Count > 0)
{
lstActiveTournamentPlayers_Byes.Shuffle();
foreach (TournamentMainPlayer player in lstActiveTournamentPlayers_Byes)
{
roundTable = new TournamentMainRoundTable();
roundTable.Number = round.Tables.Count + 1;
roundTable.Player1Id = player.PlayerId;
roundTable.Bye = true;
roundTable.Player1Score = objTournMain.MaxPoints / 2;
roundTable.Player1Winner = true;
setRoundTableNames(ref roundTable);
round.Tables.Add(roundTable);
}
}
//Add/Save the round
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
try
{
conn.Update(objTournMain); //Update any other information that was saved such as Bye counts and such
conn.InsertWithChildren(round, true);
}
catch (Exception ex)
{
DisplayAlert("Warning!", "Error adding round to tournament! " + ex.Message, "OK");
}
OnAppearing();
}
}
public ActionResult AddNewRound(bool swiss, int topCut, string activePlayers)
{
List <TournamentMainPlayer> result = JsonConvert.DeserializeObject <List <TournamentMainPlayer> >(activePlayers);
//Flag each current player as inactive
foreach (TournamentMainPlayer currentPlayer in objTournMain.Players)
{
currentPlayer.Active = false;
}
//Then determine which, if any, should be active.
foreach (TournamentMainPlayer resultPlayer in result)
{
foreach (TournamentMainPlayer currentPlayer in objTournMain.Players)
{
if (currentPlayer.PlayerId == resultPlayer.PlayerId)
{
resultPlayer.Id = currentPlayer.Id;
currentPlayer.Active = true;
currentPlayer.Bye = resultPlayer.Bye;
break;
}
}
}
//Determine if there are any new players to be added
foreach (TournamentMainPlayer resultPlayer in result)
{
if (resultPlayer.Id == 0)
{
foreach (Player player in lstPlayersAll)
{
if (player.Id == resultPlayer.PlayerId)
{
TournamentMainPlayer newNextRoundPlayer = new TournamentMainPlayer
{
Id = 0,
TournamentId = tournamentId,
PlayerId = player.Id,
PlayerName = player.Name,
Active = true,
Bye = resultPlayer.Bye
};
objTournActivity.TournamentMain.Players.Add(newNextRoundPlayer);
}
}
}
}
var request = new RestRequest("TournamentsPlayers/{userid}/{id}", Method.PUT);
request.AddUrlSegment("userid", Utilities.CurrentUser.Id);
request.AddUrlSegment("id", tournamentId);
request.AddJsonBody(JsonConvert.SerializeObject(objTournActivity.TournamentMain));
// execute the request
IRestResponse response = client.Execute(request);
var content = response.Content;
//Start up the next round
StartRound(swiss, topCut);
return(View(objTournActivity));
}
public static async System.Threading.Tasks.Task <string> ImportAllAsync()
{
client = Utilities.InitializeRestClient();
if (App.IsUserLoggedIn)
{
try
{
//Get the current players saved locally
List <Player> lstCurrentPlayers = new List <Player>();
List <TournamentMain> lstCurrentTournaments = new List <TournamentMain>();
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
Utilities.InitializeTournamentMain(conn);
lstCurrentPlayers = conn.Query <Player>("SELECT * FROM Player WHERE Active = ? AND DateDeleted IS NULL ORDER BY Name", true);
lstCurrentTournaments = conn.Query <TournamentMain>("SELECT * FROM TournamentMain WHERE DateDeleted IS NULL ORDER BY StartDate");
}
//Import general Players and general Tournament info
await ImportPlayersAsync(lstCurrentPlayers);
await ImportTournamentsAsync(lstCurrentTournaments);
//Import specific player, round, and table data for each tournament
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
//Collect most up-to-date Player info since they've been imported, collecting API Ids
lstCurrentPlayers = new List <Player>();
lstCurrentPlayers = conn.Query <Player>("SELECT * FROM Player WHERE Active = ? AND DateDeleted IS NULL ORDER BY Name", true);
Dictionary <int, int> dctAPIPlayerId = new Dictionary <int, int>();
foreach (Player player in lstCurrentPlayers)
{
if (!dctAPIPlayerId.ContainsKey(player.API_Id))
{
dctAPIPlayerId.Add(player.API_Id, player.Id);
}
}
lstCurrentTournaments = new List <TournamentMain>();
lstCurrentTournaments = conn.Query <TournamentMain>("SELECT * FROM TournamentMain WHERE DateDeleted IS NULL ORDER BY StartDate");
//Go through each saved Tournament on device, pulling the detailed round/table data for each
TournamentMain objTournMain;
foreach (TournamentMain localTournament in lstCurrentTournaments)
{
objTournMain = new TournamentMain();
objTournMain = conn.GetWithChildren <TournamentMain>(localTournament.Id, true);
if (objTournMain.API_Id > 0)
{
var request = new RestRequest("Tournaments/{userid}/{id}", Method.GET);
request.AddUrlSegment("userid", App.CurrentUser.Id);
request.AddUrlSegment("id", objTournMain.API_Id);
// execute the request
var response = await client.ExecuteTaskAsync(request);
var content = response.Content;
List <TournamentMain> result = JsonConvert.DeserializeObject <List <TournamentMain> >(JsonConvert.DeserializeObject(content).ToString());
foreach (TournamentMain ApiTournament in result)
{
//Add/update Tournament Player data
foreach (TournamentMainPlayer ApiTournPlayer in ApiTournament.Players)
{
TournamentMainPlayer updatePlayer = new TournamentMainPlayer()
{
Active = ApiTournPlayer.Active,
API_Id = ApiTournPlayer.Id,
Bye = ApiTournPlayer.Bye,
ByeCount = ApiTournPlayer.ByeCount,
MOV = ApiTournPlayer.MOV,
PlayerId = (dctAPIPlayerId.ContainsKey(ApiTournPlayer.PlayerId) ? dctAPIPlayerId[ApiTournPlayer.PlayerId] : 0),
PlayerName = ApiTournPlayer.PlayerName,
Rank = ApiTournPlayer.Rank,
RoundsPlayed = ApiTournPlayer.RoundsPlayed,
TournamentId = objTournMain.Id
};
foreach (TournamentMainPlayer localPlayer in objTournMain.Players)
{
if (localPlayer.PlayerId == updatePlayer.PlayerId)
{
updatePlayer.Id = localPlayer.Id;
break;
}
}
if (updatePlayer.Id == 0)
{
conn.Insert(updatePlayer);
}
else
{
conn.Update(updatePlayer);
}
}
//Add/Update/Delete Rounds
foreach (TournamentMainRound ApiRound in ApiTournament.Rounds)
{
TournamentMainRound updateRound = new TournamentMainRound()
{
API_Id = ApiRound.Id,
Number = ApiRound.Number,
RoundTimeEnd = ApiRound.RoundTimeEnd,
Swiss = ApiRound.Swiss,
TournamentId = objTournMain.Id
};
//Grab the device's SQL round Id
foreach (TournamentMainRound localRound in objTournMain.Rounds)
{
if (localRound.API_Id == updateRound.API_Id)
{
updateRound.Id = localRound.Id;
break;
}
}
if (updateRound.Id == 0)
{
conn.Insert(updateRound);
TournamentMainRound tmp = conn.Query <TournamentMainRound>("SELECT * FROM TournamentMainRound WHERE TournamentId = ? ORDER BY Id DESC", updateRound.TournamentId)[0];
updateRound.Id = tmp.Id; //We need this latest RoundId so that the tables will be associated with the correct round
}
else
{
conn.Update(updateRound);
}
//Add/update table data
foreach (TournamentMainRoundTable ApiTable in ApiRound.Tables)
{
TournamentMainRoundTable updateTable = new TournamentMainRoundTable()
{
API_Id = ApiTable.Id,
Bye = ApiTable.Bye,
Number = ApiTable.Number,
Player1Id = (dctAPIPlayerId.ContainsKey(ApiTable.Player1Id) ? dctAPIPlayerId[ApiTable.Player1Id] : 0),
Player1Name = ApiTable.Player1Name,
Player1Score = ApiTable.Player1Score,
Player1Winner = ApiTable.Player1Winner,
Player2Id = (dctAPIPlayerId.ContainsKey(ApiTable.Player2Id) ? dctAPIPlayerId[ApiTable.Player2Id] : 0),
Player2Name = ApiTable.Player2Name,
Player2Score = ApiTable.Player2Score,
Player2Winner = ApiTable.Player2Winner,
ScoreTied = ApiTable.ScoreTied,
TableName = ApiTable.TableName,
RoundId = updateRound.Id
};
//Grab the device's SQL table Id
foreach (TournamentMainRound localRound in objTournMain.Rounds)
{
if (localRound.Id == updateTable.RoundId)
{
foreach (TournamentMainRoundTable localTable in localRound.Tables)
{
if (localTable.API_Id == updateTable.API_Id)
{
updateTable.Id = localTable.Id;
break;
}
}
break;
}
}
if (updateTable.Id == 0)
{
conn.Insert(updateTable);
}
else
{
conn.Update(updateTable);
}
}
}
//Delete any local rounds that are saved, but were removed online
foreach (TournamentMainRound localRound in objTournMain.Rounds)
{
bool blnDeleteRound = true;
foreach (TournamentMainRound ApiRound in ApiTournament.Rounds)
{
if (ApiRound.Id == localRound.API_Id)
{
blnDeleteRound = false;
break;
}
}
if (blnDeleteRound)
{
conn.Delete(localRound);
}
}
break;
}
}
}
}
}
catch (Exception ex)
{
Console.Write("Error:" + ex.Message);
return("Error: " + ex.Message);
}
return("Import success");
}
return("");
}
