/// <summary> /// Removes a user by the name /// </summary> /// <param name="username">The name of the user to remove</param> /// <returns>True if saved; false is not</returns> public bool RemoveUser(String username) { TournamentUserModel user = Model.TournamentUsers.First(x => x.Name == username); services.Tournament.DeleteTournamentUser(user.TournamentUserID); return(services.Save()); }
/// <summary> /// Marks a TournamentUser as checked-in for a tournament. /// </summary> /// <param name="tournamentUserId"> Id of the TournamentUser that is being checked-in. </param> public void CheckUserIn(int tournamentUserId) { TournamentUserModel tournamentUser = unitOfWork.TournamentUserRepo.Get(tournamentUserId); tournamentUser.CheckInTime = DateTime.Now; tournamentUser.IsCheckedIn = true; }
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> /// Removes a user by the user's accuontID /// </summary> /// <param name="accountId">ID of user's accuont</param> /// <returns>True if saved; false is not</returns> public bool RemoveUser(int accountId) { TournamentUserModel user = Model.TournamentUsers.First(x => x.AccountID == accountId); services.Tournament.DeleteTournamentUser(user.TournamentUserID); return(services.Save()); }
public bool isAccountCheckedIn(int accountId) { TournamentUserModel userModel = Model.TournamentUsers.SingleOrDefault(x => x.AccountID == accountId); bool checkedIn = userModel.IsCheckedIn != null ? (bool)userModel.IsCheckedIn : false; return(checkedIn); }
public bool CheckUserIn(int tournamentUserId) { TournamentUserModel userModel = Model.TournamentUsers.SingleOrDefault(x => x.TournamentUserID == tournamentUserId); services.Tournament.CheckUserIn(userModel.TournamentUserID); return(services.Save()); }
/// <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()); }
public void Get_Challenger() { var db = new DatabaseRepository("VictoriousEntities"); TournamentUserModel user = db.GetMatch(db.GetAllMatchesInBracket(1)[0].MatchID).Challenger; TournamentUserModel user2 = db.GetAllUsersInTournament(3)[0]; Assert.AreEqual(user, user2); }
/// <summary> /// Creates a TournamentUserModel of this Player. /// </summary> /// <param name="_tournamentId">ID of containing Tournament</param> public TournamentUserModel GetTournamentUserModel(int _tournamentId) { TournamentUserModel model = new TournamentUserModel(); //model.AccountID = this.AccountId; model.TournamentUserID = this.Id; model.Name = this.Name; model.TournamentID = _tournamentId; return(model); }
public Permission GetAccountPermission(int accountId) { TournamentUserModel user = Model.TournamentUsers.SingleOrDefault(x => x.AccountID == accountId); if (user != null) { return((Permission)user.PermissionLevel); } return(Permission.NONE); }
public void AddTournamentUser_Save() { TournamentUserModel tournamentUser = NewTournamentUser(); tournamentUser.Name = unitOfWork.AccountRepo.GetAll().ToList()[0].Username; tournamentUser.TournamentID = service.GetAllTournaments()[0].TournamentID; service.AddTournamentUser(tournamentUser); var result = unitOfWork.Save(); Assert.AreEqual(true, result); }
private TournamentUserModel NewTournamentUser() { TournamentUserModel user = new TournamentUserModel() { Name = "Kelton", //Username = Guid.NewGuid().ToString(), UniformNumber = 1 }; return(user); }
public bool isUserCheckedIn(int tournamentUserId) { bool checkedIn = false; TournamentUserModel userModel = Model.TournamentUsers.SingleOrDefault(x => x.TournamentUserID == tournamentUserId); if (userModel != null) { checkedIn = userModel.IsCheckedIn != null ? (bool)userModel.IsCheckedIn : false; } return(checkedIn); }
public Permission GetUserPermission(int tournamentUserId) { TournamentUserModel user = Model.TournamentUsers.Single(x => x.TournamentUserID == tournamentUserId); if (user != null) { return((Permission)user.PermissionLevel); } return(Permission.NONE); }
public Player(TournamentUserModel _model) { if (null == _model) { throw new ArgumentNullException("_model"); } this.Id = _model.TournamentUserID; this.Name = _model.Name; this.Email = ""; }
public void Update_Challenger() { var db = new DatabaseRepository("VictoriousEntities"); TournamentUserModel user = db.GetMatch(db.GetAllMatchesInBracket(1)[0].MatchID).Challenger; MatchModel match = db.GetAllMatchesInBracket(db.GetAllBracketsInTournament(db.GetAllTournaments()[0].TournamentID)[0].BracketID)[0]; match.Challenger.Name = "bob"; var db2 = new DatabaseRepository("VictoriousEntities"); db2.UpdateTournamentUser(user); Assert.AreEqual("bob", user.Name); }
public void Change_Challenger_By_ChallengerID() { var db = new DatabaseRepository("VictoriousEntities"); MatchModel match = db.GetAllMatchesInBracket(db.GetAllBracketsInTournament(db.GetAllTournaments()[0].TournamentID)[0].BracketID)[0]; var db2 = new DatabaseRepository("VictoriousEntities"); match.ChallengerID = db2.GetAllUsersInTournament(db2.GetAllTournaments()[0].TournamentID)[2].TournamentUserID; db2.UpdateMatch(match); TournamentUserModel user = db.GetAllUsersInTournament(db2.GetAllTournaments()[0].TournamentID)[2]; MatchModel match2 = db.GetMatch(match.MatchID); Assert.AreEqual(match2.Challenger, user); }
/// <summary> /// Adds a user to the tournament /// </summary> /// <param name="name">The name of the user</param> /// <returns>The user model of the created user</returns> public TournamentUserModel AddUser(String name) { bool isEmail = false; TournamentUserModel userModel = null; if (!isEmail) { userModel = new TournamentUserModel() { Name = name, PermissionLevel = (int)Permission.TOURNAMENT_STANDARD, TournamentID = Model.TournamentID }; } return(AddUserToTournament(userModel) ? userModel : null); }
public void Add_Match_And_Get_Challenger() { var db = new DatabaseRepository("VictoriousEntities"); MatchModel match = new MatchModel() { BracketID = 3, ChallengerID = 1, DefenderID = 2, MatchNumber = 1 }; db.AddMatch(match); TournamentUserModel user = match.Challenger; Assert.AreEqual(db.GetTournamentUser(match.ChallengerID), user); }
public bool AddUser(Account account, Permission permission) { // Verify this user doesn't exist in the tournament if (!Model.TournamentUsers.Any(x => x.AccountID == account.Model.AccountID)) { TournamentUserModel tournamentUserModel = new TournamentUserModel() { AccountID = account.Model.AccountID, Name = account.Model.Username, PermissionLevel = (int)permission, TournamentID = Model.TournamentID }; return(AddUserToTournament(tournamentUserModel)); } else { return(false); } }
public JsonResult NoAccountRegister(int tournamentId, String name, int bracketId) { if (account.IsLoggedIn()) { Models.Tournament tournament = new Models.Tournament(service, tournamentId); // Is an Administrator registering a user? if (tournament.IsAdmin(account.Model.AccountID)) { TournamentUserModel model = tournament.AddUser(name); data = new { user = new { Name = model.Name, Permission = model.PermissionLevel, TournamentUserId = model.TournamentUserID, Seed = tournament.GetUserSeed(bracketId, model.TournamentUserID) }, actions = tournament.PermissionAction(account.Model.AccountID, model.TournamentUserID, "default") }; if (data != null) { status = true; } message = "User was " + (status ? "" : "not") + " added successfully"; } else { message = "You are not allowed to register a user."; } } else { message = "You need to login first."; } return(BundleJson()); }
/// <summary> /// Updates a single TournamentUser. /// </summary> /// <param name="tournamentUser"> The TournamentUser to be updated. <param> public void UpdateTournamentUser(TournamentUserModel tournamentUser) { unitOfWork.TournamentUserRepo.Update(tournamentUser); }
/// <summary> /// Adds a single TournamentUser to the databse. /// </summary> /// <param name="tournamentUser"> The TournamentUser to be added. </param> public void AddTournamentUser(TournamentUserModel tournamentUser) { unitOfWork.TournamentUserRepo.Add(tournamentUser); }
public Dictionary <String, int> PermissionAction(int accountId, int tournamentUserId, String action) { TournamentUserModel targetAccount = Model.TournamentUsers.First(x => x.TournamentUserID == tournamentUserId); bool accountIsAdmin = IsAdmin(accountId); bool accountIsCreator = IsCreator(accountId); Dictionary <String, int> permissionActions = new Dictionary <string, int>(); permissionActions.Add("Demote", 0); permissionActions.Add("Promote", 0); permissionActions.Add("Remove", 0); permissionActions.Add("Permission", -1); switch (action) { case "promote": switch ((Permission)targetAccount.PermissionLevel) { case Permission.TOURNAMENT_STANDARD: if (accountIsCreator) { targetAccount.PermissionLevel = (int)Permission.TOURNAMENT_ADMINISTRATOR; services.Tournament.UpdateTournamentUser(targetAccount); permissionActions["Demote"] = 1; } break; case Permission.TOURNAMENT_ADMINISTRATOR: break; case Permission.TOURNAMENT_CREATOR: break; } break; case "remove": case "demote": switch ((Permission)targetAccount.PermissionLevel) { case Permission.TOURNAMENT_STANDARD: if (accountIsAdmin) { targetAccount.PermissionLevel = (int)Permission.NONE; services.Tournament.DeleteTournamentUser(targetAccount.TournamentUserID); } break; case Permission.TOURNAMENT_ADMINISTRATOR: if (accountIsCreator) { targetAccount.PermissionLevel = (int)Permission.TOURNAMENT_STANDARD; services.Tournament.UpdateTournamentUser(targetAccount); permissionActions["Remove"] = 1; permissionActions["Promote"] = 1; } break; case Permission.TOURNAMENT_CREATOR: break; } break; default: switch ((Permission)targetAccount.PermissionLevel) { case Permission.TOURNAMENT_STANDARD: if (targetAccount.AccountID != null) { if (accountIsCreator) { permissionActions["Remove"] = 1; permissionActions["Promote"] = 1; } else if (accountIsAdmin) { permissionActions["Remove"] = 1; } } else { if (accountIsAdmin || accountIsCreator) { permissionActions["Remove"] = 1; } } break; case Permission.TOURNAMENT_ADMINISTRATOR: if (accountIsCreator) { permissionActions["Demote"] = 1; } break; case Permission.TOURNAMENT_CREATOR: break; } break; } permissionActions["Permission"] = targetAccount.PermissionLevel != null ? (int)targetAccount.PermissionLevel : -1; if (services.Save()) { return(permissionActions); } else { return(null); } }