//Set the copy of the table
public TournamentMainRoundTable_ViewModel(TournamentMainRoundTable table, bool enabled = true)
{
_enabled = enabled;
TournamentMainRoundTable = new TournamentMainRoundTable();
TournamentMainRoundTable = table;
UpdatePlayerVisual();
}
private void setRoundTableNames(ref TournamentMainRoundTable roundTable)
{
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
Player player;
string strPlayer1Name = "N/A";
string strPlayer2Name = "N/A";
if (roundTable.Player1Id > 0)
{
player = conn.Get <Player>(roundTable.Player1Id);
strPlayer1Name = player.Name;
}
if (roundTable.Player2Id > 0)
{
player = conn.Get <Player>(roundTable.Player2Id);
strPlayer2Name = player.Name;
}
roundTable.Player1Name = strPlayer1Name;
roundTable.Player2Name = strPlayer2Name;
roundTable.TableName = string.Format("{0} vs {1}", strPlayer1Name, strPlayer2Name);
}
}
public string UpdateTableData(string table)
{
TournamentMainRoundTable result = JsonConvert.DeserializeObject <TournamentMainRoundTable>(table);
try
{
//Update database
var request = new RestRequest("TournamentsRounds/{userid}/{id}", Method.PUT);
request.AddUrlSegment("userid", Utilities.CurrentUser.Id);
request.AddUrlSegment("id", result.RoundId);
result.Player1Name = "";
result.Player2Name = "";
request.AddJsonBody(JsonConvert.SerializeObject(result));
// execute the request
IRestResponse response = client.Execute(request);
var content = response.Content; // raw content as string
if (content.ToUpper().Contains("PUT: SUCCESS"))
{
foreach (TournamentMainRound round in objTournMain.Rounds)
{
if (round.Id == result.RoundId)
{
foreach (TournamentMainRoundTable rdTable in round.Tables)
{
if (rdTable.Id == result.Id)
{
rdTable.Player1Score = result.Player1Score;
rdTable.Player1Winner = result.Player1Winner;
rdTable.Player2Score = result.Player2Score;
rdTable.Player2Winner = result.Player2Winner;
rdTable.ScoreTied = result.ScoreTied;
}
}
break;
}
}
}
return(objTournActivity.GetStandings());
}
catch (Exception ex)
{
Console.Write(string.Format("TournamentActivityController.UpdateTableData{0}Error:{1}", Environment.NewLine, ex.Message));
}
return("");
}
//Update the SQL table after all the adjustments are made
public void UpdateRoundTable()
{
if (TournamentMainRoundTable.Id == 0 || _recursiveLvl > 1)
{
return;
}
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
TournamentMainRoundTable roundTable = conn.Get <TournamentMainRoundTable>(TournamentMainRoundTable.Id);
roundTable.Player1Score = TournamentMainRoundTable.Player1Score;
roundTable.Player1Winner = TournamentMainRoundTable.Player1Winner;
roundTable.Player2Score = TournamentMainRoundTable.Player2Score;
roundTable.Player2Winner = TournamentMainRoundTable.Player2Winner;
conn.Update(roundTable);
}
}
private void StartRound(bool blnSwiss, int intTableCount)
{
bool blnProceed = false;
//Create a new round
TournamentMainRound round = new TournamentMainRound();
round.TournamentId = intTournID;
round.Number = objTournMain.Rounds.Count + 1;
round.Swiss = blnSwiss;
List <TournamentMainPlayer> lstActiveTournamentPlayers = new List <TournamentMainPlayer>();
List <TournamentMainPlayer> lstActiveTournamentPlayers_Byes = new List <TournamentMainPlayer>();
if (blnSwiss)
{
blnProceed = SetupSwissPlayers(ref lstActiveTournamentPlayers, ref lstActiveTournamentPlayers_Byes);
}
else
{
blnProceed = SetupSingleEliminationPlayers(ref lstActiveTournamentPlayers, intTableCount);
}
//If players weren't able to be successfully setup correctly, don't create a new round
if (!blnProceed)
{
return;
}
//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;
}
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
foreach (TournamentMainPlayer player in objTournMain.Players)
{
conn.Update(player); //Player info can change due to flagging/unflagging a player Bye
}
conn.InsertWithChildren(round, true);
}
catch (Exception ex)
{
DisplayAlert("Warning!", "Error adding round to tournament! " + ex.Message, "OK");
}
OnAppearing();
}
}
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 Tournaments_RoundInfoTableEdit(int intRoundId, int intTableId)
{
InitializeComponent();
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
currentRound = new TournamentMainRound();
currentRound = conn.GetWithChildren <TournamentMainRound>(intRoundId);
lstPlayers = new List <clsPlayerInfo>();
foreach (TournamentMainRoundTable table in currentRound.Tables)
{
if (table.Player1Id > 0)
{
lstPlayers.Add(new clsPlayerInfo(table.Player1Id, table.Player1Name, table.Id));
}
if (table.Player2Id > 0)
{
lstPlayers.Add(new clsPlayerInfo(table.Player2Id, table.Player2Name, table.Id));
}
if (table.Id == intTableId)
{
currentTable = table;
Title = table.TableName;
lblPlayer1.Text = table.Player1Name;
lblPlayer2.Text = table.Player2Name;
intPlayer1Id = table.Player1Id;
intPlayer2Id = table.Player2Id;
}
}
pckPlayer1.ItemsSource = lstPlayers.OrderBy(obj => obj.PlayerName).Where(o => o.PlayerId != intPlayer2Id).ToList();
pckPlayer2.ItemsSource = lstPlayers.OrderBy(obj => obj.PlayerName).Where(o => o.PlayerId != intPlayer1Id).ToList();
//Set the first selected item as the current player
pckPlayer1.SelectedIndexChanged -= pckPlayer1_SelectedIndexChanged;
pckPlayer2.SelectedIndexChanged -= pckPlayer2_SelectedIndexChanged;
for (int i = 1; i <= 2; i++)
{
int intIndex = -1;
Picker pckPlayer = (i == 1 ? pckPlayer1 : pckPlayer2);
foreach (clsPlayerInfo item in pckPlayer.ItemsSource)
{
intIndex++;
if (item.PlayerId == (i == 1 ? intPlayer1Id : intPlayer2Id))
{
pckPlayer.SelectedIndex = intIndex;
break;
}
}
}
pckPlayer1.SelectedIndexChanged += pckPlayer1_SelectedIndexChanged;
pckPlayer2.SelectedIndexChanged += pckPlayer2_SelectedIndexChanged;
}
}
private void saveButton_Clicked(object sender, EventArgs e)
{
clsPlayerInfo player1 = (clsPlayerInfo)pckPlayer1.SelectedItem;
clsPlayerInfo player2 = (clsPlayerInfo)pckPlayer2.SelectedItem;
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
TournamentMainRoundTable tmpOtherTable;
TournamentMainRoundTable tmpCurrentTable;
clsPlayerInfo tmpPlayer;
int tmpPlayerId;
for (int i = 1; i <= 2; i++)
{
if (i == 1)
{
tmpPlayer = player1;
tmpPlayerId = intPlayer1Id;
}
else
{
tmpPlayer = player2;
tmpPlayerId = intPlayer2Id;
}
if (tmpPlayer.PlayerId != tmpPlayerId)
{
tmpOtherTable = new TournamentMainRoundTable();
tmpCurrentTable = new TournamentMainRoundTable();
TournamentMainRoundTable otherTable = conn.Get <TournamentMainRoundTable>(tmpPlayer.TableId);
tmpOtherTable.Player1Id = otherTable.Player1Id;
tmpOtherTable.Player1Name = otherTable.Player1Name;
tmpOtherTable.Player2Id = otherTable.Player2Id;
tmpOtherTable.Player2Name = otherTable.Player2Name;
tmpCurrentTable.Player1Id = currentTable.Player1Id;
tmpCurrentTable.Player1Name = currentTable.Player1Name;
tmpCurrentTable.Player2Id = currentTable.Player2Id;
tmpCurrentTable.Player2Name = currentTable.Player2Name;
if (otherTable.Player1Id == tmpPlayer.PlayerId)
{
otherTable.Player1Id = tmpCurrentTable.Player1Id;
otherTable.Player1Name = tmpCurrentTable.Player1Name;
otherTable.TableName = string.Format("{0} vs {1}", otherTable.Player1Name, otherTable.Player2Name);
currentTable.Player1Id = tmpOtherTable.Player1Id;
currentTable.Player1Name = tmpOtherTable.Player1Name;
currentTable.TableName = string.Format("{0} vs {1}", currentTable.Player1Name, currentTable.Player2Name);
}
else if (otherTable.Player2Id == tmpPlayer.PlayerId)
{
otherTable.Player2Id = tmpCurrentTable.Player1Id;
otherTable.Player2Name = tmpCurrentTable.Player1Name;
otherTable.TableName = string.Format("{0} vs {1}", otherTable.Player1Name, otherTable.Player2Name);
currentTable.Player1Id = tmpOtherTable.Player2Id;
currentTable.Player1Name = tmpOtherTable.Player2Name;
currentTable.TableName = string.Format("{0} vs {1}", currentTable.Player1Name, currentTable.Player2Name);
}
conn.Update(otherTable);
conn.Update(currentTable);
}
}
//if (player1.PlayerId != intPlayer1Id)
//{
// tmpTable = new TournamentMainRoundTable();
// TournamentMainRoundTable otherTable = conn.Get<TournamentMainRoundTable>(player1.TableId);
// tmpTable = otherTable;
// if (otherTable.Player1Id == player1.PlayerId)
// {
// otherTable.Player1Id = currentTable.Player1Id;
// otherTable.Player1Name = currentTable.Player1Name;
// otherTable.TableName = string.Format("{0} vs {1}", otherTable.Player1Name, otherTable.Player2Name);
// currentTable.Player1Id = tmpTable.Player1Id;
// currentTable.Player1Name = tmpTable.Player1Name;
// currentTable.TableName = string.Format("{0} vs {1}", currentTable.Player1Name, currentTable.Player2Name);
// }
// else if (otherTable.Player2Id == player1.PlayerId)
// {
// otherTable.Player2Id = currentTable.Player1Id;
// otherTable.Player2Name = currentTable.Player1Name;
// otherTable.TableName = string.Format("{0} vs {1}", otherTable.Player1Name, otherTable.Player2Name);
// currentTable.Player1Id = tmpTable.Player2Id;
// currentTable.Player1Name = tmpTable.Player2Name;
// currentTable.TableName = string.Format("{0} vs {1}", currentTable.Player1Name, currentTable.Player2Name);
// }
//}
//if (player2.PlayerId != intPlayer2Id)
//{
// tmpTable = new TournamentMainRoundTable();
// TournamentMainRoundTable otherTable = conn.Get<TournamentMainRoundTable>(player2.TableId);
// tmpTable = otherTable;
// if (otherTable.Player1Id == player2.PlayerId)
// {
// otherTable.Player1Id = currentTable.Player1Id;
// otherTable.Player1Name = currentTable.Player1Name;
// otherTable.TableName = string.Format("{0} vs {1}", otherTable.Player1Name, otherTable.Player2Name);
// currentTable.Player1Id = tmpTable.Player1Id;
// currentTable.Player1Name = tmpTable.Player1Name;
// currentTable.TableName = string.Format("{0} vs {1}", currentTable.Player1Name, currentTable.Player2Name);
// }
// else if (otherTable.Player2Id == player2.PlayerId)
// {
// otherTable.Player2Id = currentTable.Player1Id;
// otherTable.Player2Name = currentTable.Player1Name;
// otherTable.TableName = string.Format("{0} vs {1}", otherTable.Player1Name, otherTable.Player2Name);
// currentTable.Player1Id = tmpTable.Player2Id;
// currentTable.Player1Name = tmpTable.Player2Name;
// currentTable.TableName = string.Format("{0} vs {1}", currentTable.Player1Name, currentTable.Player2Name);
// }
//}
}
Navigation.PopAsync();
}
private void saveButton_Clicked(object sender, EventArgs e)
{
clsPlayerInfo player1 = (clsPlayerInfo)pckPlayer1.SelectedItem;
clsPlayerInfo player2 = (clsPlayerInfo)pckPlayer2.SelectedItem;
using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH))
{
TournamentMainRoundTable tmpOtherTable;
TournamentMainRoundTable tmpCurrentTable;
clsPlayerInfo tmpPlayer;
int tmpPlayerId;
//Go through each Picker set of players
for (int i = 1; i <= 2; i++)
{
if (i == 1)
{
tmpPlayer = player1;
tmpPlayerId = intPlayer1Id;
}
else
{
tmpPlayer = player2;
tmpPlayerId = intPlayer2Id;
}
//If the currently selected player is not the same player that was loaded, proceed
if (tmpPlayer.PlayerId != tmpPlayerId)
{
tmpOtherTable = new TournamentMainRoundTable();
tmpCurrentTable = new TournamentMainRoundTable();
TournamentMainRoundTable otherTable = conn.Get <TournamentMainRoundTable>(tmpPlayer.TableId);
//Ensure we're not swamping player spots within the same table. If so, can create issues with this logic that there's really no need to code for at this point.
if (otherTable.Id != currentTable.Id)
{
//Set local temp object properties instead of copying the objects themselves, preventing inadvertently changing table data unintentionally
tmpOtherTable.Player1Id = otherTable.Player1Id;
tmpOtherTable.Player1Name = otherTable.Player1Name;
tmpOtherTable.Player2Id = otherTable.Player2Id;
tmpOtherTable.Player2Name = otherTable.Player2Name;
tmpCurrentTable.Player1Id = currentTable.Player1Id;
tmpCurrentTable.Player1Name = currentTable.Player1Name;
tmpCurrentTable.Player2Id = currentTable.Player2Id;
tmpCurrentTable.Player2Name = currentTable.Player2Name;
//Find player being swapped with on the other tableId, determine if player 1 or 2, keeping in mind if the current table's player is player 1 or 2 already
//(that way we can swap a player 1 from one table to a player 2 on another table)
if (tmpOtherTable.Player1Id == tmpPlayer.PlayerId)
{
if (i == 1)
{
currentTable.Player1Id = tmpOtherTable.Player1Id;
currentTable.Player1Name = tmpOtherTable.Player1Name;
otherTable.Player1Id = tmpCurrentTable.Player1Id;
otherTable.Player1Name = tmpCurrentTable.Player1Name;
}
else
{
currentTable.Player2Id = tmpOtherTable.Player1Id;
currentTable.Player2Name = tmpOtherTable.Player1Name;
otherTable.Player1Id = tmpCurrentTable.Player2Id;
otherTable.Player1Name = tmpCurrentTable.Player2Name;
}
}
else if (tmpOtherTable.Player2Id == tmpPlayer.PlayerId)
{
if (i == 1)
{
currentTable.Player1Id = tmpOtherTable.Player2Id;
currentTable.Player1Name = tmpOtherTable.Player2Name;
otherTable.Player2Id = tmpCurrentTable.Player1Id;
otherTable.Player2Name = tmpCurrentTable.Player1Name;
}
else
{
currentTable.Player2Id = tmpOtherTable.Player2Id;
currentTable.Player2Name = tmpOtherTable.Player2Name;
otherTable.Player2Id = tmpCurrentTable.Player2Id;
otherTable.Player2Name = tmpCurrentTable.Player2Name;
}
}
//Reset the tables' names
currentTable.TableName = string.Format("{0} vs {1}", currentTable.Player1Name, currentTable.Player2Name);
otherTable.TableName = string.Format("{0} vs {1}", otherTable.Player1Name, otherTable.Player2Name);
}
//Update the tables' information on the database
conn.Update(otherTable);
conn.Update(currentTable);
}
}
}
Navigation.PopAsync();
}
//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 string SwapTablePlayers(int roundId, int tableId, int originalPlayerId, int newPlayerId)
{
try
{
//Grab the tables we're going to need
TournamentMainRoundTable table1 = null;
TournamentMainRoundTable table2 = null;
foreach (TournamentMainRound round in objTournMain.Rounds)
{
if (round.Id == roundId)
{
foreach (TournamentMainRoundTable table in round.Tables)
{
if (table.Id == tableId)
{
table1 = table;
}
else
{
if (table.Player1Id == newPlayerId || table.Player2Id == newPlayerId)
{
table2 = table;
}
}
}
break;
}
}
//If we're able to find valid tables, proceed with swapping players
//table1 = starting table (from the table we're swapping said player)
//table2 = new table (to the table we're moving said player)
if (table1 != null && table2 != null)
{
string strOriginalPlayerName = "";
string strNewPlayerName = "";
//Set variables to help facilitate the swap
if (table1.Player1Id == originalPlayerId)
{
strOriginalPlayerName = table1.Player1Name;
}
else
{
strOriginalPlayerName = table1.Player2Name;
}
if (table2.Player1Id == newPlayerId)
{
strNewPlayerName = table2.Player1Name;
}
else
{
strNewPlayerName = table2.Player2Name;
}
//Make the swap
if (table1.Player1Id == originalPlayerId)
{
table1.Player1Id = newPlayerId;
table1.Player1Name = strNewPlayerName;
}
else
{
table1.Player2Id = newPlayerId;
table1.Player2Name = strNewPlayerName;
}
if (table2.Player1Id == newPlayerId)
{
table2.Player1Id = originalPlayerId;
table2.Player1Name = strOriginalPlayerName;
}
else
{
table2.Player2Id = originalPlayerId;
table2.Player2Name = strOriginalPlayerName;
}
//Set table names
table1.TableName = string.Format("{0} vs {1}", table1.Player1Name, table1.Player2Name);
table2.TableName = string.Format("{0} vs {1}", table2.Player1Name, table2.Player2Name);
//Update database, update each table accordingly
foreach (TournamentMainRoundTable table in new List <TournamentMainRoundTable> {
table1, table2
})
{
var request = new RestRequest("TournamentsRounds/{userid}/{id}", Method.PUT);
request.AddUrlSegment("userid", Utilities.CurrentUser.Id);
request.AddUrlSegment("id", table.RoundId);
request.AddJsonBody(JsonConvert.SerializeObject(table));
// execute the request
IRestResponse response = client.Execute(request);
var content = response.Content; // raw content as string
}
return("Player Swap SUCCESS");
}
}
catch (Exception ex)
{
Console.Write(string.Format("TournamentActivityController.SwapTablePlayers{0}Error:{1}", Environment.NewLine, ex.Message));
}
return("");
}
private void StartRound(bool blnSwiss, int intTopCut)
{
//Create a new round
TournamentMainRound round = new TournamentMainRound();
round.TournamentId = tournamentId;
round.Number = objTournActivity.TournamentMain.Rounds.Count + 1;
round.Swiss = blnSwiss;
List <TournamentMainPlayer> lstActiveTournamentPlayers = new List <TournamentMainPlayer>();
List <TournamentMainPlayer> lstActiveTournamentPlayers_Byes = new List <TournamentMainPlayer>();
if (blnSwiss)
{
SetupSwissPlayers(ref lstActiveTournamentPlayers, ref lstActiveTournamentPlayers_Byes);
}
else
{
SetupSingleEliminationPlayers(ref lstActiveTournamentPlayers, intTopCut);
}
//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);
roundTable.TableName = string.Format("{0} vs {1}", roundTable.Player1Name, roundTable.Player2Name);
round.Tables.Add(roundTable);
roundTable = new TournamentMainRoundTable();
}
if (roundTable.Player1Id == 0)
{
roundTable.Number = round.Tables.Count + 1;
roundTable.Player1Id = player.PlayerId;
roundTable.Player1Name = player.PlayerName;
}
else if (roundTable.Player2Id == 0)
{
roundTable.Player2Id = player.PlayerId;
roundTable.Player2Name = player.PlayerName;
}
}
//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;
}
roundTable.TableName = string.Format("{0} vs {1}", roundTable.Player1Name, roundTable.Player2Name);
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.Player1Name = player.PlayerName;
roundTable.Bye = true;
roundTable.Player1Score = objTournMain.MaxPoints / 2;
roundTable.Player1Winner = true;
roundTable.TableName = string.Format("{0} vs {1}", roundTable.Player1Name, "N/A");
round.Tables.Add(roundTable);
}
}
objTournMain.Rounds.Add(round);
//Create round and associated tables on database
var request = new RestRequest("TournamentsRounds/{userid}/{id}", Method.POST);
request.AddUrlSegment("userid", Utilities.CurrentUser.Id);
request.AddUrlSegment("id", round.Id);
request.AddJsonBody(JsonConvert.SerializeObject(round));
// execute the request
IRestResponse response = client.Execute(request);
var content = response.Content;
}
// PUT api/values/5 (UPDATE)
public string Put(int userid, int id, [FromBody] string value)
{
if (!Utilities.IsValidated(Request.Headers))
{
return("Validation fail");
}
try
{
//TournamentMainRound round = JsonConvert.DeserializeObject<TournamentMainRound>(JsonConvert.DeserializeObject(value).ToString());
TournamentMainRoundTable table = JsonConvert.DeserializeObject <TournamentMainRoundTable>(JsonConvert.DeserializeObject(value).ToString());
using (SqlConnection sqlConn = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["XWTWebConnectionString"].ToString()))
{
sqlConn.Open();
////Create new round
//using (SqlCommand sqlCmd = new SqlCommand("dbo.spTournamentsRounds_UPDATEINSERT", sqlConn))
//{
// sqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
// sqlCmd.Parameters.AddWithValue("@TournamentId", round.TournamentId);
// sqlCmd.Parameters.AddWithValue("@Number", round.Number);
// sqlCmd.Parameters.AddWithValue("@Swiss", round.Swiss);
// sqlCmd.Parameters.AddWithValue("@RoundTimeEnd", round.RoundTimeEnd);
// SqlParameter outputParameter = new SqlParameter("@Id", SqlDbType.Int);
// outputParameter.Value = id;
// outputParameter.Direction = ParameterDirection.InputOutput;
// sqlCmd.Parameters.Add(outputParameter);
// //Grab the new ID, if applicable
// using (SqlDataReader sqlRdr = sqlCmd.ExecuteReader())
// {
// id = Convert.ToInt32(outputParameter.Value);
// }
//}
//Create/update table data sent in
DataTable dt = new DataTable();
dt.Columns.Add("Id", typeof(int));
dt.Columns.Add("RoundId", typeof(int));
dt.Columns.Add("Number", typeof(int));
dt.Columns.Add("TableName", typeof(string));
dt.Columns.Add("ScoreTied", typeof(bool));
dt.Columns.Add("Bye", typeof(bool));
dt.Columns.Add("Player1Id", typeof(int));
dt.Columns.Add("Player1Name", typeof(string));
dt.Columns.Add("Player1Score", typeof(int));
dt.Columns.Add("Player1Winner", typeof(bool));
dt.Columns.Add("Player2Id", typeof(int));
dt.Columns.Add("Player2Name", typeof(string));
dt.Columns.Add("Player2Score", typeof(int));
dt.Columns.Add("Player2Winner", typeof(bool));
//foreach (TournamentMainRoundTable table in round.Tables)
//{
dt.Rows.Add(table.Id, table.RoundId, table.Number, table.TableName, table.ScoreTied, table.Bye
, table.Player1Id, table.Player1Name, table.Player1Score, table.Player1Winner
, table.Player2Id, table.Player2Name, table.Player2Score, table.Player2Winner);
//}
using (SqlCommand sqlCmd = new SqlCommand("dbo.spTournamentsRoundsTable_UPDATEINSERT_DT", sqlConn))
{
sqlCmd.CommandType = System.Data.CommandType.StoredProcedure;
sqlCmd.Parameters.AddWithValue("@RoundId", id);
sqlCmd.Parameters.Add("@TableDataTable", SqlDbType.Structured).Value = dt;
sqlCmd.ExecuteNonQuery();
}
}
}
catch (Exception ex)
{
return(ex.Message);
}
return("PUT: Success");
}
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("");
}
