async private void timerRoundBtn_Clicked(object sender, EventArgs e) { if (dteRoundTimeEnd > DateTime.Now) { var answer = await DisplayAlert("Round In Progress", "Would you like to cancel the current timer?", "Yes", "No"); if (answer) { //Update round's end-time using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH)) { TournamentMainRound round = new TournamentMainRound(); round = conn.GetWithChildren <TournamentMainRound>(intRoundId); round.RoundTimeEnd = DateTime.Now; conn.Update(round); dteRoundTimeEnd = round.RoundTimeEnd ?? DateTime.Now; } //Cancel any pending notifications CrossLocalNotifications.Current.Cancel(cintMidNotifyId); CrossLocalNotifications.Current.Cancel(cintEndNotifyId); App.MasterMainPage.CancelRoundTimer(); } return; } else { timerPopup.IsVisible = true; timerOptionsEntry.Text = intDefaultRoundLength.ToString(); } }
//Delete the last round async private void deleteRoundBtn_Activated(object sender, EventArgs e) { if (objTournMain.Rounds.Count == 0) { await DisplayAlert("Warning!", "There are no rounds to actually delete!", "Ugh"); return; } var confirmed = await DisplayAlert("Confirm", "Do you want to delete Round " + objTournMain.Rounds.Count + "? This cannot be undone!", "Yes", "No"); if (confirmed) { using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH)) { this.IsBusy = true; try { //Grab the latest round and delete it TournamentMainRound round = objTournMain.Rounds[objTournMain.Rounds.Count - 1]; conn.Delete(round, true); } catch (Exception ex) { await DisplayAlert("Warning!", "Error deleting round from tournament! " + ex.Message, "OK"); } OnAppearing(); } } }
public Tournaments_RoundInfo(string strTitle, int intRoundId, int intRoundCount) { InitializeComponent(); Title = strTitle; this.intRoundId = intRoundId; using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH)) { TournamentMainRound round = new TournamentMainRound(); round = conn.GetWithChildren <TournamentMainRound>(intRoundId); bool blnEnableRows = (round.Number < intRoundCount ? false : true); //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) ObservableCollection <TournamentMainRoundTable_ViewModel> lstTables = new ObservableCollection <TournamentMainRoundTable_ViewModel>(); foreach (TournamentMainRoundTable table in round.Tables) { lstTables.Add(new TournamentMainRoundTable_ViewModel(table, blnEnableRows)); } tournamentTableListView.ItemsSource = lstTables; if (!blnEnableRows) { timerRoundBtn.IsVisible = false; tournamentTableListView.ItemTapped -= tournamentTableListView_ItemTapped; } else { timerRoundBtn.IsVisible = true; } } }
public Tournaments_RoundInfo(Tournaments_AllInfo allInfoPage, string strTitle, int intRoundId, int intRoundCount) { InitializeComponent(); Title = strTitle; intDefaultRoundLength = allInfoPage.intDefaultRoundLength; this.intRoundId = intRoundId; //Tie the loading Overlay to the main page since this is what will be flagged as "IsBusy" when generating new rounds etc. loadingOverlay.BindingContext = allInfoPage; timerRoundBtn_VM = new TournamentMainRoundInfoTimer_ViewModel(); timerRoundBtn.BindingContext = timerRoundBtn_VM; using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH)) { TournamentMainRound round = new TournamentMainRound(); round = conn.GetWithChildren <TournamentMainRound>(intRoundId); intRoundNumber = round.Number; bool blnEnableRows = (round.Number < intRoundCount ? false : true); blnEnableRows = true; //Keeping them all enabled for now //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) ObservableCollection <TournamentMainRoundTable_ViewModel> lstTables = new ObservableCollection <TournamentMainRoundTable_ViewModel>(); foreach (TournamentMainRoundTable table in round.Tables) { lstTables.Add(new TournamentMainRoundTable_ViewModel(table, blnEnableRows)); } tournamentTableListView.ItemsSource = lstTables; if (!blnEnableRows) { timerRoundBtn.IsVisible = false; tournamentTableListView.ItemTapped -= tournamentTableListView_ItemTapped; } else { timerRoundBtn.IsVisible = true; //If the round time started previously, keep it going if (round.RoundTimeEnd > DateTime.Now) { dteRoundTimeEnd = round.RoundTimeEnd ?? DateTime.Now; TimeSpan time = (round.RoundTimeEnd ?? DateTime.Now) - DateTime.Now; App.MasterMainPage.RoundTimer(time, Convert.ToInt32(time.TotalSeconds), ref timerRoundBtn_VM); } } } }
// POST api/values (CREATE) public string Post([FromBody] string value) { if (!Utilities.IsValidated(Request.Headers)) { return("Validation fail"); } try { TournamentMainRound round = JsonConvert.DeserializeObject <TournamentMainRound>(JsonConvert.DeserializeObject(value).ToString()); using (SqlConnection sqlConn = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["XWTWebConnectionString"].ToString())) { sqlConn.Open(); using (SqlCommand sqlCmd = new SqlCommand("dbo.spTournamentRoundTimer_UPDATE", sqlConn)) { sqlCmd.CommandType = System.Data.CommandType.StoredProcedure; sqlCmd.Parameters.AddWithValue("@RoundId", round.Id); sqlCmd.Parameters.AddWithValue("@RoundTimeEnd", round.RoundTimeEnd); using (SqlDataReader sqlReader = sqlCmd.ExecuteReader()) { while (sqlReader.Read()) { TournamentsController tourns = new TournamentsController(); //returnTournaments.Add(JsonConvert.DeserializeObject<TournamentMain>(JsonConvert.DeserializeObject(tourns.Get(sqlReader.GetInt32(sqlReader.GetOrdinal("UserAccountId")), sqlReader.GetInt32(sqlReader.GetOrdinal("Id")))).ToString())); } } } } } catch (Exception ex) { return(ex.Message); } return("POST: SUCCESS"); }
private void saveTimerRoundBtn_Clicked(object sender, EventArgs e) { this.IsBusy = true; //int intTime = Convert.ToInt16(timerOptionsPicker.Items[timerOptionsPicker.SelectedIndex]); int intTime = Convert.ToInt16(timerOptionsEntry.Text); intTime *= 60; //Converting to seconds //Set the end time for the round DateTime roundTimeMid = DateTime.Now.AddSeconds(intTime / 2); DateTime roundTimeEnd = DateTime.Now.AddSeconds(intTime); //Set phone notification CrossLocalNotifications.Current.Cancel(cintMidNotifyId); CrossLocalNotifications.Current.Cancel(cintEndNotifyId); CrossLocalNotifications.Current.Show("Round " + intRoundNumber.ToString() + " is halfway over.", "Almost there!", cintMidNotifyId, roundTimeMid); CrossLocalNotifications.Current.Show("Round " + intRoundNumber.ToString() + " is over.", "Finish your round.", cintEndNotifyId, roundTimeEnd); //Get the TimeSpan and set the round timer right away TimeSpan time = roundTimeEnd - DateTime.Now; App.MasterMainPage.RoundTimer(time, intTime, ref timerRoundBtn_VM); //Save what the end time is at so that the timer is accurate if returning later using (SQLite.SQLiteConnection conn = new SQLite.SQLiteConnection(App.DB_PATH)) { TournamentMainRound round = new TournamentMainRound(); round = conn.GetWithChildren <TournamentMainRound>(intRoundId); round.RoundTimeEnd = roundTimeEnd; conn.Update(round); dteRoundTimeEnd = roundTimeEnd; } timerPopup.IsVisible = false; this.IsBusy = false; }
private bool StartRoundPreCheck(ref bool blnSwiss) { //Make sure we actually have players if (objTournMain.Players.Count == 0) { DisplayAlert("Warning!", "You must add players first to this tournament!", "D'oh!"); return(false); } //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); Utilities.CalculatePlayerScores(ref objTournMain); conn.UpdateWithChildren(objTournMain); //Update any other information that was saved such as Bye counts and such } TournamentMainRound latestRound = objTournMain.Rounds[objTournMain.Rounds.Count - 1]; blnSwiss = latestRound.Swiss; //Check if the last round was a Swiss Round or not //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(false); } } } return(true); }
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; } }
//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(); } }
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; }
// POST api/values (CREATE) public string Post(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()); 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); Creating round, so no need to pass this at all 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("POST: 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(""); }
private async void LoadOnlineActiveTournamentsAsync() { loadingOverlay_LogScore.IsVisible = true; loadingOverlay_Standings.IsVisible = true; //Pull tournaments user is registered for IRestRequest request = new RestRequest("TournamentsSearch/{userid}", Method.GET); request.AddUrlSegment("userid", App.CurrentUser.Id.ToString()); // execute the request var response = await client.ExecuteTaskAsync(request); string content = response.Content; List <TournamentMain> returnedTournaments = JsonConvert.DeserializeObject <List <TournamentMain> >(JsonConvert.DeserializeObject(content).ToString()); associatedTournaments = new List <TournamentMain>(); if (returnedTournaments.Count > 0) { tournamentStandingsTableListView.ItemsSource = returnedTournaments; associatedTournaments.AddRange(returnedTournaments); } associatedLogScoreTables = new List <TournamentMainRoundTable>(); //Go through the returned associated tournaments, grab the latest round's info and ensure the user is at one of the tables foreach (TournamentMain tournament in returnedTournaments) { if (tournament.Rounds.Count > 0) { TournamentMainRound lastestRound = tournament.Rounds[tournament.Rounds.Count - 1]; int intTournPlayerId = 0; foreach (TournamentMainPlayer player in tournament.Players) { if (player.API_UserAccountId == App.CurrentUser.Id) { intTournPlayerId = player.PlayerId; break; } } if (intTournPlayerId > 0) { foreach (TournamentMainRoundTable table in lastestRound.Tables) { if (table.Player1Id == intTournPlayerId || table.Player2Id == intTournPlayerId) { table.TableName = string.Format("{0}: {1}", tournament.Name, table.TableName); if (table.Bye) { table.TableName += " (BYE)"; } table.Bye = !table.Bye; //Flip this since the Binding can't do that associatedLogScoreTables.Add(table); break; } } } } } logScoreTableListView.ItemsSource = associatedLogScoreTables; loadingOverlay_LogScore.IsVisible = false; loadingOverlay_Standings.IsVisible = false; }