private void UpdateMatchFromViewModel(UpdateMatchViewModel viewModel, Match match, User player1, User player2)
{
if (match.IsComplete) {
var results = match.Results.ToList();
foreach (var result in results) {
repository.Delete(result);
}
match.Results.Clear();
}
match.Winner = viewModel.Winner == player1.Id ? player1 : player2;
match.IsComplete = true;
match.IsForfeit = viewModel.IsForfeit;
if (!match.IsForfeit) {
match.DatePlayed = DateTime.Parse(viewModel.Date + " " + viewModel.Time);
var matchResult = new MatchResult(player1,
viewModel.Player1Innings,
viewModel.Player1DefensiveShots,
viewModel.Player1Wins);
match.AddResult(matchResult);
matchResult = new MatchResult(player2,
viewModel.Player2Innings,
viewModel.Player2DefensiveShots,
viewModel.Player2Wins);
match.AddResult(matchResult);
}
// set meet to complete if all matches are complete
var meet = match.Meet;
meet.IsComplete = !meet.Matches.Where(m => !m.IsComplete).Any();
// must do this because EF is stupid
var d = meet.Division;
}
public virtual void AddMatch(Match match)
{
var allTeamPlayers = (from team in Teams
from player in team.Players
select player).ToList();
if (match.Players.Where(p => !allTeamPlayers.Contains(p.Player)).Any()) {
throw new ArgumentException("all players in match must be members of the meet's teams", "match");
}
if (!Matches.Contains(match)) {
match.Meet = this;
Matches.Add(match);
}
}
private MatchPlayerViewModel CreateMatchPlayerViewModel(User player, Match match)
{
var model = new MatchPlayerViewModel();
model.Id = player.Id;
model.Name = player.FullName;
var slQuery = player.SkillLevels.Where(sl => sl.GameType == match.Meet.Division.Season.GameType);
if (slQuery.Any()) {
model.SkillLevel = slQuery.First().Value;
}
else {
model.SkillLevel = 0;
}
// initialize my results, if this match is complete
if (match.IsComplete) {
model.Winner = match.Winner == player;
if (!match.IsForfeit) {
var result = match.Results.Where(r => r.Player == player).First();
model.Innings = result.Innings.ToString();
model.DefensiveShots = result.DefensiveShots.ToString();
model.Wins = result.Wins.ToString();
}
}
// calculate my season record & win percentage
var completedMatches = from meet in match.Meet.Division.Meets
where meet.IsComplete
from ma in meet.Matches
where ma.Players.Where(p => p.Player == player).Any()
select ma;
int wins = 0;
int losses = 0;
double winPercentage = 0;
foreach (var completedMatch in completedMatches) {
if (completedMatch.Winner == player) {
wins++;
}
else {
losses++;
}
}
if (wins + losses > 0) {
winPercentage = (double)wins / (double)(wins + losses);
}
model.Record = string.Format("{0} - {1} ({2})", wins, losses, winPercentage.ToString(".00"));
return model;
}
private LastMatchViewModel CreateLastMatchViewModel(Match match)
{
var model = new LastMatchViewModel();
if (!match.IsForfeit) {
var results = new List<MatchResultViewModel>();
foreach (var result in match.Results) {
var resultvm = new MatchResultViewModel(result);
resultvm.Winner = match.Winner == result.Player;
results.Add(resultvm);
}
model.Results = results;
}
else {
// this match was a forfeit, create results to display
var results = new List<MatchResultViewModel>();
foreach (var matchPlayer in match.Players) {
var result = new MatchResultViewModel();
result.Player = matchPlayer.Player.FullName;
result.Winner = match.Winner == matchPlayer.Player;
results.Add(result);
}
model.Results = results;
}
return model;
}
private MatchViewModel CreateMatchViewModel(Match match)
{
var model = new MatchViewModel();
model.Id = match.Id;
model.IsComplete = match.IsComplete;
model.IsForfeit = match.IsForfeit;
var players = match.Players.ToArray();
model.Player1 = CreateMatchPlayerViewModel(players[0].Player, match);
model.Player2 = CreateMatchPlayerViewModel(players[1].Player, match);
if (match.IsComplete) {
if (!match.IsForfeit) {
model.DatePlayed = match.DatePlayed.Value.ToShortDateString();
model.TimePlayed = match.DatePlayed.Value.ToShortTimeString();
model.Status = string.Format("Played on {0} {1}", model.DatePlayed, model.TimePlayed);
}
else {
model.Status = "Forfeited";
}
}
else {
model.Status = "Incomplete";
}
return model;
}
private UpdateMatchResponseViewModel VerifyUserCanUpdateMatch(Match match, User player1, User player2)
{
// authorize only admins, officers, and players involved in this meet
var currentPrincipal = authService.GetCurrentPrincipal();
var loggedInUser = repository.All<User>().Single(u => u.Username.Equals(currentPrincipal.Identity.Name));
if (!match.Meet.UserCanEnterMatchResults(loggedInUser)) {
return new UpdateMatchResponseViewModel(false, "You do not have permission to enter results for this match");
}
if (null == player1 || !match.Players.Where(p => p.Player == player1).Any()) {
return new UpdateMatchResponseViewModel(false, "Player 1 is not a valid player for this match");
}
if (null == player2 || !match.Players.Where(p => p.Player == player2).Any()) {
return new UpdateMatchResponseViewModel(false, "Player 2 is not a valid player for this match");
}
return null;
}
public virtual void RemoveMatch(Match match)
{
if (Matches.Contains(match)) {
Matches.Remove(match);
match.Meet = null;
}
}
private ScoresheetMatchViewModel CreateScoresheetMatchViewModel(Match match)
{
var model = new ScoresheetMatchViewModel();
model.Id = match.Id;
var gameType = match.Meet.Division.Season.GameType;
var players = match.Players.ToArray();
model.Player1 = CreatePlayerViewModel(players[0].Player, gameType);
model.Player2 = CreatePlayerViewModel(players[1].Player, gameType);
model.Player1.GamesToWin = CalculateGamesToWin(model.Player1.SkillLevel, model.Player2.SkillLevel);
model.Player2.GamesToWin = CalculateGamesToWin(model.Player2.SkillLevel, model.Player1.SkillLevel);
return model;
}
