protected override ValidationResult IsValid(object value, ValidationContext validationContext)
 {
     using (var repoProvider = new RepoProvider())
     {
         string newName = value.ToString().Trim();
         var playerFound = repoProvider.PlayerRepo.Get(newName);
         if(playerFound != null)
         {
             return new ValidationResult(this.FormatErrorMessage(validationContext.DisplayName));
         }
     }
     return null;
 }
示例#2
0
 public async Task<int> GetHandicap(RepoProvider repoProvider, WeekModel week, Guid playerId)
 {
     var result = 0;
     if (week.BeenPlayed)
     {
         result = repoProvider.RoundRepo.GetWeeklyRound(playerId, week.WeekId).Handicap;
     }
     else
     {
         result = await ServiceProvider.HandicapInstance.CalculateHandicap(playerId);
     }
     return result;
 }
        public async Task<AddPlayerMatchupViewModel> Get()
        {
            AddPlayerMatchupViewModel vm = new AddPlayerMatchupViewModel();

            using (var repoProvider = new RepoProvider())
            {
                var highestWeekNbr = repoProvider.WeekRepo.GetHighestWeekNumber();
                vm.NextWeek = ++highestWeekNbr;
                vm.Players = new List<BasicPlayerViewModel>();
                foreach (var player in await repoProvider.PlayerRepo.GetAll())
                {
                    vm.Players.Add(new BasicPlayerViewModel() { Name = player.Name, Id = player.PlayerId });
                }
            }
            return vm;
        }
        private async Task<LeaderboardViewModel> getModelData()
        {
            var playerSummaryVM = new LeaderboardViewModel();
            var firstHalfPlayerColl = new List<PlayerLeaderboardViewModel>();
            var secondHalfPlayerColl = new List<PlayerLeaderboardViewModel>();

            using (var repoProvider = new RepoProvider())
            {
                playerSummaryVM.WeeksPlayed = (await repoProvider.WeekRepo.GetPlayedWeeks()).Count();
                //first half
                foreach (var player in await repoProvider.PlayerRepo.GetAll())
                {
                    var playerVM = new PlayerLeaderboardViewModel() { Name = player.Name };
                    playerVM.CurrentHandicap = await ServiceProvider.HandicapInstance.CalculateHandicap(player.PlayerId);
                    playerVM.ScoreAvg = repoProvider.RoundRepo.GetPlayerScoreAverage(player.PlayerId, true);
                    playerVM.TotalPoints = repoProvider.RoundRepo.GetPlayerTotalPoints(player.PlayerId, true);
                    playerVM.Birds = repoProvider.RoundRepo.GetPlayerBirieTotal(player.PlayerId, true);
                    playerVM.Pars = repoProvider.RoundRepo.GetPlayerParTotal(player.PlayerId, true);
                    playerVM.Bogeys = repoProvider.RoundRepo.GetPlayerBogeyTotal(player.PlayerId, true);

                    firstHalfPlayerColl.Add(playerVM);
                }
                //second half
                foreach (var player in await repoProvider.PlayerRepo.GetAll())
                {
                    var playerVM = new PlayerLeaderboardViewModel() { Name = player.Name };
                    playerVM.CurrentHandicap = await ServiceProvider.HandicapInstance.CalculateHandicap(player.PlayerId);
                    playerVM.ScoreAvg = repoProvider.RoundRepo.GetPlayerScoreAverage(player.PlayerId, false);
                    playerVM.TotalPoints = repoProvider.RoundRepo.GetPlayerTotalPoints(player.PlayerId, false);
                    playerVM.Birds = repoProvider.RoundRepo.GetPlayerBirieTotal(player.PlayerId, false);
                    playerVM.Pars = repoProvider.RoundRepo.GetPlayerParTotal(player.PlayerId, false);
                    playerVM.Bogeys = repoProvider.RoundRepo.GetPlayerBogeyTotal(player.PlayerId, false);

                    secondHalfPlayerColl.Add(playerVM);
                }
            }


            playerSummaryVM.FirstHalfPlayerSummary = firstHalfPlayerColl.OrderByDescending(t => t.TotalPoints).ToList();
            playerSummaryVM.SecondHalfPlayerSummary = secondHalfPlayerColl.OrderByDescending(t => t.TotalPoints).ToList();
            return playerSummaryVM;
        }
 public async Task<IHttpActionResult> Post(AddNewPlayerMatchupViewModel vm)
 {
     if (ModelState.IsValid && vm.NewPlayerMatchups.Count > 0)
     {
         //Todo:Validate that each player is selected only once.
         using (var repoProvider = new RepoProvider())
         {
             WeekModel weekObj = new WeekModel() { WeekId = Guid.NewGuid(), BeenPlayed = false, WeekNbr = vm.WeekNbr, ScoreCreateDate = DateTime.Now };
             repoProvider.WeekRepo.Add(weekObj);
             for (int i = 0; i < vm.NewPlayerMatchups.Count; i++)
             {
                 MatchupModel matchupObj = new MatchupModel() { MatchupId = Guid.NewGuid(), WeekId = weekObj.WeekId, Player1 = vm.NewPlayerMatchups[i].Player1Id, Player2 = vm.NewPlayerMatchups[i].Player2Id };
                 repoProvider.MatchupRepo.Add(matchupObj);
             }
             await repoProvider.SaveAllRepoChangesAsync();
         }
         return Ok();
     }
     return BadRequest();
 }
示例#6
0
        public async Task<MatchupWeekViewModel> Get(int weekNbr = 0)
        {
            var globalExistingMatchups = new List<MatchupModel>();
            var vm = new MatchupWeekViewModel();
            vm.WeekNbr = weekNbr;
            using (var repoProvider = new RepoProvider())
            {
                var players = await repoProvider.PlayerRepo.GetAll();
                var weeksUnordered = await repoProvider.WeekRepo.GetAll();
                var weeks = weeksUnordered.OrderBy(w => w.WeekNbr);
                foreach (var week in weeks.Where(w => w.WeekNbr > weekNbr))
                {
                    var matchups = await repoProvider.MatchupRepo.GetAllWeeklyMatchups(week.WeekId);
                    globalExistingMatchups.AddRange(matchups);

                }


                List<MatchupModel> newMatchups = new List<MatchupModel>();
                var nextPlayer = getNextPlayerDoesNotHaveMatchup(players, newMatchups);
                while (nextPlayer != null)
                {
                    addNewRandomMatchupForPlayer(nextPlayer, players, newMatchups, globalExistingMatchups);
                    nextPlayer = getNextPlayerDoesNotHaveMatchup(players, newMatchups);
                }

                vm.Matchups = new List<MatchupViewModel>();
                foreach (var m in newMatchups)
                {
                    var p1 = await repoProvider.PlayerRepo.Get(m.Player1);
                    var p2 = await repoProvider.PlayerRepo.Get(m.Player2);
                    vm.Matchups.Add(new MatchupViewModel() { Player1Name = p1.Name, Player2Name = p2.Name });
                }
                //hydrate names into a viewmodel
            }

            return vm;

        }
示例#7
0
        private async Task<IEnumerable<WeekResultsViewModel>> getModelData()
        {
            var weekColl = new List<WeekResultsViewModel>();

            using (var repoProvider = new RepoProvider())
            {

                foreach (var week in await repoProvider.WeekRepo.GetPlayedWeeks())
                {
                    var weekResultsVM = new WeekResultsViewModel()
                    {
                        WeekNbr = week.WeekNbr,
                        ScoreCreateDate = week.ScoreCreateDate,
                        PlayerRounds = new List<PlayerRoundViewModel>()
                    };

                    foreach (var round in await repoProvider.RoundRepo.GetWeeklyRounds(week.WeekId))
                    {
                        var player = await repoProvider.PlayerRepo.Get(round.PlayerRefId);
                        var playerRoundVM = new PlayerRoundViewModel()
                        {
                            TotalPoints = round.TotalPoints,
                            TotalScore = round.TotalScore,
                            Name = player.Name,
                            Birdies = round.BirdieCnt,
                            Pars = round.ParCnt,
                            Bogeys = round.BogeyCnt,
                            PlayerId = round.PlayerRefId.ToString()
                        };

                        weekResultsVM.PlayerRounds.Add(playerRoundVM);
                    }
                    weekColl.Add(weekResultsVM);
                }
            }
            return weekColl.OrderByDescending(w => w.ScoreCreateDate);
        }
示例#8
0
        private async Task<PlayercardViewModel> getModelData(string id)
        {
            PlayercardViewModel vm = new PlayercardViewModel();
            using (var repoProvider = new RepoProvider())
            {
                if (!string.IsNullOrEmpty(id))
                {
                    Guid pGuid = new Guid(id);
                    var player = await repoProvider.PlayerRepo.Get(pGuid);
                    vm.Name = player.Name;
                    vm.Handicap = await ServiceProvider.HandicapInstance.CalculateHandicap(player.PlayerId);
                    vm.AvgScore = repoProvider.RoundRepo.GetPlayerScoreAverage(player.PlayerId);
                    vm.SeasonLow = repoProvider.RoundRepo.GetPlayerLowRound(player.PlayerId);
                    vm.SeasonHigh = repoProvider.RoundRepo.GetPlayerHighRound(player.PlayerId);
                    vm.WeeklyRounds = new List<WeeklyRoundViewModel>();

                    var pRound = await repoProvider.RoundRepo.GetPlayerRounds(pGuid);

                    foreach (var round in pRound)
                    {
                        var weekModel = await repoProvider.WeekRepo.Get(round.WeekId);

                        vm.WeeklyRounds.Add(new WeeklyRoundViewModel()
                        {
                            Birdies = round.BirdieCnt,
                            Pars = round.ParCnt,
                            Bogeys = round.BogeyCnt,
                            Points = round.TotalPoints,
                            Score = round.TotalScore,
                            WeekNbr = weekModel.WeekNbr
                        });
                    }
                    vm.WeeklyRounds = vm.WeeklyRounds.OrderBy(r => r.WeekNbr).ToList();
                }
            }
            return vm;
        }
        public async Task<AddRoundWeekViewModel> Get()
        {
            AddRoundWeekViewModel vm = new AddRoundWeekViewModel() { PlayerRounds = new List<AddRoundViewModel>() };

            using (var repoProvider = new RepoProvider())
            {
                var week = repoProvider.WeekRepo.GetFirstUnplayedWeek();
                vm.HasUnplayedWeeks = false;

                if (week != null)
                {
                    vm.HasUnplayedWeeks = true;
                    vm.WeekNbr = week.WeekNbr;
                    vm.WeekId = week.WeekId;

                    foreach (var player in await repoProvider.PlayerRepo.GetAll())
                    {
                        var roundScores = new List<int>() { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
                        vm.PlayerRounds.Add(new AddRoundViewModel() { PlayerId = player.PlayerId, PlayerName = player.Name, Scores = roundScores });
                    }
                }
            }
            return vm;
        }
示例#10
0
        public async Task<int> CalculateHandicap(Guid playerId)
        {
            //HttpContext.Current.Application.Lock();
            //HttpContext.Current.Application["Name"] = "Value";
            //HttpContext.Current.Application.UnLock();
            var retVal = 0;

            using(var repoProvider = new RepoProvider())
            {
                var weeksUnsorted = await repoProvider.WeekRepo.GetPlayedWeeks();
                var weeks = weeksUnsorted.OrderByDescending(w => w.WeekNbr).ToList();
                var runningTotal = 0.0;
                var nbrRoundsWithScore = 0;
                var parTotal = 0;
                var overParTotal = 0.0;
                var player = await repoProvider.PlayerRepo.Get(playerId);
                for (int i = 0; i < _handicapWeeks && i < weeks.Count(); i++)
                {
                    var round = repoProvider.RoundRepo.GetWeeklyRound(playerId, weeks[i].WeekId);
                    runningTotal += (round.TotalScore * _roundAdjustment);
                    if (round.TotalScore != 0)
                    {
                        nbrRoundsWithScore++;
                        var thisPar = round.Front?_roundParFront:_roundParBack;
                        parTotal += thisPar;
                        var diff = (round.TotalScore - thisPar) * _roundAdjustment;
                        overParTotal += diff;
                    }
                }
                if (player.HandicapRound1 > 0)
                {
                    runningTotal += (player.HandicapRound1 * _roundAdjustment);
                    nbrRoundsWithScore++;
                    parTotal += _roundParFront;
                    var diff = (player.HandicapRound1 - _roundParFront) * _roundAdjustment;
                    overParTotal += diff;
                }
                if (player.HandicapRound2 > 0)
                {
                    runningTotal += (player.HandicapRound2 * _roundAdjustment);
                    nbrRoundsWithScore++;
                    parTotal += _roundParBack;
                    var diff = (player.HandicapRound2 - _roundParBack) * _roundAdjustment;
                    overParTotal += diff;
                }
                if(nbrRoundsWithScore > 0 && runningTotal > 0.0)
                {
                    //Third Scoring Method
                    double avg = overParTotal / nbrRoundsWithScore;

                    //Second Version
                    //double totalOverPar = runningTotal - parTotal;
                    //double avg = totalOverPar / nbrRoundsWithScore;
                    
                    retVal = (int)Math.Round(avg, 0, MidpointRounding.AwayFromZero);
                    
                    //First version
                    //double avg = runningTotal / nbrRoundsWithScore;
                    //retVal = (int)Math.Round(avg, 0, MidpointRounding.AwayFromZero) - _roundPar;
                }
            }
            return retVal;
        }
示例#11
0
        public async Task<IHttpActionResult> Post(AddRoundWeekViewModel vm)
        {
            if (ModelState.IsValid)
            {
                using (var repoProvider = new RepoProvider())
                {
                    var week = await repoProvider.WeekRepo.Get(vm.WeekId);
                    week.BeenPlayed = true;
                    week.ScoreCreateDate = DateTime.Now;

                    bool front = vm.FrontBack.Equals("Front");
                    var course = repoProvider.CourseRepo.Get();
                    var pars = front ? HttpContext.Current.Application["FrontPars"] as List<Par> :
                        HttpContext.Current.Application["BackPars"] as List<Par>;
                    var parList = pars.Select(p => p.ParValue);

                    bool half = vm.FirstHalf.Equals("First");

                    var matchups = await repoProvider.MatchupRepo.GetAllWeeklyMatchups(vm.WeekId);
                    foreach (var matchup in matchups)
                    {
                        var postedRoundPlayer1 = vm.PlayerRounds.First(r => r.PlayerId.CompareTo(matchup.Player1) == 0);
                        var postedRoundPlayer2 = vm.PlayerRounds.First(r => r.PlayerId.CompareTo(matchup.Player2) == 0);
                        var p1Handicap = await ServiceProvider.HandicapInstance.CalculateHandicap(matchup.Player1);
                        var p2Handicap = await ServiceProvider.HandicapInstance.CalculateHandicap(matchup.Player2);
                        List<ScoringResultModel> scoringResults = ServiceProvider.ScoringInstance.ScoreMatchup(parList, postedRoundPlayer1.Scores, postedRoundPlayer2.Scores, p1Handicap, p2Handicap);

                        var p1NewRound = new RoundModel()
                        {
                            PlayerRefId = postedRoundPlayer1.PlayerId,
                            RoundId = Guid.NewGuid(),
                            WeekId = vm.WeekId,
                            Scores = ServiceProvider.ScoringInstance.ExtractScores(postedRoundPlayer1.Scores),
                            Front = front,
                            SeasonFirstHalf = half,
                            Handicap = p1Handicap,
                            TotalScore = ServiceProvider.ScoringInstance.RoundTotalScore(postedRoundPlayer1.Scores),
                            TotalPoints = scoringResults[0].Points,
                            BirdieCnt = scoringResults[0].Birdies,
                            ParCnt = scoringResults[0].Pars,
                            EagleCnt = scoringResults[0].Eagles,
                            BogeyCnt = scoringResults[0].Bogeys
                        };
                        var p2NewRound = new RoundModel()
                        {
                            PlayerRefId = postedRoundPlayer2.PlayerId,
                            RoundId = Guid.NewGuid(),
                            WeekId = vm.WeekId,
                            Scores = ServiceProvider.ScoringInstance.ExtractScores(postedRoundPlayer2.Scores),
                            Front = front,
                            SeasonFirstHalf = half,
                            Handicap = p2Handicap,
                            TotalScore = ServiceProvider.ScoringInstance.RoundTotalScore(postedRoundPlayer2.Scores),
                            TotalPoints = scoringResults[1].Points,
                            BirdieCnt = scoringResults[1].Birdies,
                            ParCnt = scoringResults[1].Pars,
                            EagleCnt = scoringResults[1].Eagles,
                            BogeyCnt = scoringResults[1].Bogeys
                        };
                        repoProvider.RoundRepo.Add(p1NewRound);
                        repoProvider.RoundRepo.Add(p2NewRound);
                    }
                    await repoProvider.SaveAllRepoChangesAsync();
                }
                return Ok();
            }
            return BadRequest();
        }
示例#12
0
        private async Task<MatchupSummaryViewModel> getModelData()
        {
            MatchupSummaryViewModel vm = new MatchupSummaryViewModel();
            var weekColl = new List<MatchupWeekViewModel>();

            using (var repoProvider = new RepoProvider())
            {
                foreach (var week in await repoProvider.WeekRepo.GetAll())
                {
                    var matchupWeekVM = new MatchupWeekViewModel() { WeekNbr = week.WeekNbr, Matchups = new List<MatchupViewModel>() };
                    foreach (var matchup in await repoProvider.MatchupRepo.GetAllWeeklyMatchups(week.WeekId))
                    {
                        var p1 = await repoProvider.PlayerRepo.Get(matchup.Player1);
                        var p2 = await repoProvider.PlayerRepo.Get(matchup.Player2);

                        var matchupVM = new MatchupViewModel() { Player1Name = p1.Name, Player2Name = p2.Name };
                        matchupVM.Player1Handicap = await ServiceProvider.HandicapInstance.GetHandicap(repoProvider, week, matchup.Player1);
                        matchupVM.Player2Handicap = await ServiceProvider.HandicapInstance.GetHandicap(repoProvider, week, matchup.Player2);
                        matchupWeekVM.Matchups.Add(matchupVM);
                    }
                    weekColl.Add(matchupWeekVM);
                }

                var highestWeekNbr = repoProvider.WeekRepo.GetHighestWeekNumber();
                vm.NextWeek = ++highestWeekNbr;
                vm.Players = new List<BasicPlayerViewModel>();
                foreach (var player in await repoProvider.PlayerRepo.GetAll())
                {
                    vm.Players.Add(new BasicPlayerViewModel() { Name = player.Name, Id = player.PlayerId });
                }
            }
            
            vm.Weeks = weekColl.OrderByDescending(w=>w.WeekNbr).ToList();

            return vm;
        }