/// <summary> /// Adds a user to the tournament of the first bracket. /// </summary> /// <param name="model">The user model to be added to the tournament</param> /// <returns>True if saved; false if save failed</returns> private bool AddUserToTournament(TournamentUserModel model) { // Add the user to the tournament services.Tournament.AddTournamentUser(model); if (model.PermissionLevel == (int)Permission.TOURNAMENT_STANDARD) { // Add user to the beginning bracket BracketModel bracket = Model.Brackets.ElementAt(0); int? seedData = bracket.TournamentUsersBrackets.Max(x => x.Seed); int seed = seedData != null ? seedData.Value + 1 : 1; TournamentUsersBracketModel bracketUser = new TournamentUsersBracketModel() { TournamentID = Model.TournamentID, TournamentUserID = model.TournamentUserID, Seed = seed, BracketID = bracket.BracketID }; services.Tournament.AddTournamentUsersBracket(bracketUser); } return(services.Save()); }
private void UpdatePlayers() { foreach (BracketModel bracketModel in Model.Brackets) { // Update the Players if (bracketModel.TournamentUsersBrackets.Count != Model.TournamentUsers.Where(x => IsUserParticipant(x.TournamentUserID)).Count()) { for (int j = 0; j < Model.TournamentUsers.Count; j++) { TournamentUserModel user = Model.TournamentUsers.ElementAt(j); TournamentUsersBracketModel model = new TournamentUsersBracketModel() { TournamentUserID = user.TournamentUserID, BracketID = bracketModel.BracketID, TournamentID = Model.TournamentID, Seed = j + 1 }; //bracketModel.TournamentUsersBrackets.Add(model); if (!IsUserAdministrator(user.TournamentUserID)) { services.Tournament.AddTournamentUsersBracket(model); } } } } }
/// <summary> /// Creates a TournamentUsersBracketModel of this Player. /// This Model will also contain the Player's bracketID and seed. /// </summary> /// <param name="_bracketId">ID of containing Bracket</param> /// <param name="_seed">Player's seed-value within the Bracket</param> /// <param name="_tournamentId">ID of containing Tournament</param> public TournamentUsersBracketModel GetTournamentUsersBracketModel(int _bracketId, int _seed, int _tournamentId) { TournamentUsersBracketModel model = new TournamentUsersBracketModel(); //model.TournamentUser = GetTournamentUserModel(_tournamentId); model.TournamentUserID = this.Id; model.BracketID = _bracketId; model.Seed = _seed; model.TournamentID = _tournamentId; return(model); }
public void Delete_TournamentUsersBracket() { var db = new DatabaseRepository("VictoriousEntities"); TournamentUsersBracketModel t = new TournamentUsersBracketModel() { TournamentUserID = 1, BracketID = 1, Seed = 1 }; var result = db.DeleteTournamentUsersBrackets(t); Assert.AreEqual(DbError.SUCCESS, result); }
public void AddTournamentUserBracket_Save() { TournamentUsersBracketModel t = new TournamentUsersBracketModel() { TournamentUserID = service.GetAllTournamentUsers()[0].TournamentUserID, BracketID = service.GetAllBrackets()[0].BracketID, TournamentID = service.GetAllTournaments()[0].TournamentID, Seed = 1 }; service.AddTournamentUsersBracket(t); var result = unitOfWork.Save(); Assert.AreEqual(true, result); }
/// <summary> /// Will progress the tournament and add new players to the net bracket /// </summary> /// <param name="bracketId">ID of the bracket</param> /// <param name="isLocked">Lock or unlock the bracket</param> /// <returns>True if saved; false if not saved</returns> public bool LockBracket(int bracketId, bool isLocked) { Tournaments.IBracket currentBracket = Tourny.Brackets.Single(x => x.Id == bracketId); Tournaments.IBracket nextBracket = Tourny.Brackets.ElementAtOrDefault(Tourny.Brackets.FindIndex(x => x == currentBracket) + 1); // Make changes to the current bracket if (currentBracket != null) { BracketModel model = Model.Brackets.Single(x => x.BracketID == bracketId); model.IsLocked = isLocked; services.Tournament.UpdateBracket(model); } if (nextBracket != null) { BracketModel nextBracketModel = Model.Brackets.Single(x => x.BracketID == nextBracket.Id); List <TournamentUsersBracketModel> usersToProceed = new List <TournamentUsersBracketModel>(); Tourny.AdvancePlayersByRanking(currentBracket, nextBracket); //nextBracketModel.TournamentUsersBrackets = nextBracket.GetModel(Model.TournamentID).TournamentUsersBrackets; foreach (Tournaments.IPlayer player in nextBracket.Players) { TournamentUsersBracketModel user = new TournamentUsersBracketModel() { BracketID = nextBracket.Id, TournamentID = Model.TournamentID, TournamentUserID = player.Id, Seed = nextBracket.GetPlayerSeed(player.Id) }; usersToProceed.Add(user); } nextBracketModel.TournamentUsersBrackets = usersToProceed; services.Tournament.UpdateBracket(nextBracketModel); } return(services.Save()); }
/// <summary> /// Creates a Model of this Bracket's current state. /// Any contained objects (Players, Matches) are also converted into Models. /// </summary> /// <remarks> /// This method is overriden in Group Stages. /// </remarks> /// <param name="_tournamentID">ID of containing Tournament</param> /// <returns>Matching BracketModel</returns> public virtual BracketModel GetModel(int _tournamentID) { BracketModel model = new BracketModel(); model.TournamentID = _tournamentID; model.BracketID = this.Id; model.BracketTypeID = Convert.ToInt32(this.BracketType); model.Finalized = this.IsFinalized; model.NumberOfGroups = 0; model.MaxRounds = this.MaxRounds; model.NumberPlayersAdvance = this.AdvancingPlayers; // Convert the BracketType to relevant model, and add it: model.BracketType = new BracketTypeModel(); model.BracketType.BracketTypeID = model.BracketTypeID; model.BracketType.Type = this.BracketType; model.BracketType.TypeName = this.BracketType.ToString("f"); // Convert all Players to Models, and add them: //model.TournamentUsersBrackets = new List<TournamentUsersBracketModel>(); foreach (IPlayer player in Players) { TournamentUsersBracketModel m = player.GetTournamentUsersBracketModel(this.Id, GetPlayerSeed(player.Id), _tournamentID); model.TournamentUsersBrackets.Add(m); } // Convert all Matches to Models, and add them: //model.Matches = new List<MatchModel>(); //if (!(this is IGroupStage)) //{ for (int n = 1; n <= NumberOfMatches; ++n) { model.Matches.Add(GetMatchModel(n)); } //} return(model); }
/// <summary> /// Deletes a single TournamentUsersBracket from the database. /// </summary> /// <param name="tournamentUserId"> The Id of the TournamentUser. </param> /// <param name="bracketId"> The Id of the Bracket that the TournamentUser is in. </param> public void DeleteTournamentUsersBracket(int tournamentUserId, int bracketId) { TournamentUsersBracketModel t = GetTournamentUsersBracket(tournamentUserId, bracketId); unitOfWork.TournamentUsersBracketRepo.DeleteEntity(t); }
/// <summary> /// Updates a single TournamentUserBracket to the database. /// </summary> /// <param name="tournamentUserBracket"> The model of the TournamentUsersBracket to update. </param> public void UpdateTournamentUsersBracket(TournamentUsersBracketModel tournamentUserBracket) { unitOfWork.TournamentUsersBracketRepo.Update(tournamentUserBracket); }
/// <summary> /// Adds a single TournamentUsersBracket to the database. /// </summary> /// <param name="tournamentUserBracket"> The model of the TournamentUsersBracket to be added. </param> public void AddTournamentUsersBracket(TournamentUsersBracketModel tournamentUserBracket) { unitOfWork.TournamentUsersBracketRepo.Add(tournamentUserBracket); }
public void UpdateSeeds(Dictionary <String, int> players, int bracketId) { foreach (KeyValuePair <String, int> player in players) { TournamentUsersBracketModel user = Model.Brackets.Single(x => x.BracketID == bracketId) .TournamentUsersBrackets.SingleOrDefault(z => z.TournamentUserID == int.Parse(player.Key)); if (user != null) { user.Seed = player.Value; services.Tournament.UpdateTournamentUsersBracket(user); } else { user = new TournamentUsersBracketModel() { Seed = player.Value, TournamentUserID = int.Parse(player.Key), TournamentID = Model.TournamentID, BracketID = bracketId }; services.Tournament.AddTournamentUsersBracket(user); } } // Pass updated seeds to IBracket, which will fix any invalid values: Tourny.Brackets.Single(x => x.Id == bracketId) .SetNewPlayerlist(Model.Brackets.Single(x => x.BracketID == bracketId) .TournamentUsersBrackets); // Give correct values to all user seeds in the first BracketModel. // This prevents two users having the same seed and being randomly sorted. BracketModel bracketModel = Model.Brackets.First(); foreach (TournamentUsersBracketModel userModel in bracketModel.TournamentUsersBrackets) { int newPlayerSeed = Tourny.Brackets .Single(b => b.Id == bracketModel.BracketID) .GetPlayerSeed(userModel.TournamentUserID); if (newPlayerSeed != userModel.Seed) { userModel.Seed = newPlayerSeed; services.Tournament.UpdateTournamentUsersBracket(userModel); } } #if false foreach (TournamentTeamBracketModel teamModel in bracketModel.TournamentTeamBrackets) { int newPlayerSeed = Tourny.Brackets .Single(b => b.Id == bracketModel.BracketID) .GetPlayerSeed(teamModel.TournamentTeamID); if (newPlayerSeed != teamModel.Seed) { teamModel.Seed = newPlayerSeed; services.Tournament.UpdateTournamentTeamsBracket(teamModel); } } #endif services.Save(); }