/// <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);
}
}
