Пример #1
0
        public ActionResult Ladders_Read([DataSourceRequest]DataSourceRequest request)
        {
            string userID = User.Identity.GetUserId();
            int id = System.Convert.ToInt32(userID);
            Users.User user = Users.User.Load(id);

            LadderCollection ladders = LadderCollection.LoadAll();
            Dictionary<Ladder, bool> laddersJoinable = new Dictionary<Ladder, bool>();

            int age = DateTime.Today.Year - user.DateOfBirth.Year;
            if (user.DateOfBirth > DateTime.Today.AddYears(-age)) age--;

            LadderPlayerCollection lpByUser = LadderPlayerCollection.LoadByPlayer(user);

            foreach (Ladder ladder in ladders)
            {
                LadderPlayerCollection lpByLadder = LadderPlayerCollection.LoadByLadder(ladder);
                if (!lpByLadder.Intersect(lpByUser).Any()) // checks to see if the player is already a part of this ladder
                {
                    if (lpByLadder.Count() < ladder.MaxPlayers || ladder.MaxPlayers == 0) //MaxPlayers = 0 is default value if null in DB, null represents unlimited
                    {
                        //check ladder status
                        if ((bool)ladder.isActive)
                        {
                            //check player status
                            if (user.isActivePlayer)
                            {
                                //check age
                                //check gender
                                //check rating <- note: ratings are on a scale of 9.0 to 1.0, with 9.0 being lower than 1.0
                                if (age >= ladder.MinAge && age <= ladder.MaxAge
                                    && user.Gender == ladder.Gender || ladder.Gender.Name == "Mixed"
                                    && user.PlayerRating.Rating <= ladder.MinRating && user.PlayerRating.Rating >= ladder.MaxRating)
                                {
                                    if (!user.Requests.Contains(ladder))
                                    {
                                        laddersJoinable.Add(ladder, true);
                                    }
                                    else
                                    {
                                        laddersJoinable.Add(ladder, false);
                                    }
                                }
                                else
                                {
                                    laddersJoinable.Add(ladder, false);
                                }
                            }
                            else
                            {
                                laddersJoinable.Add(ladder, false);
                            }
                        }
                        else
                        {
                            laddersJoinable.Add(ladder, false);
                        }
                    }
                    else
                    {
                        laddersJoinable.Add(ladder, false);
                    }
                }
                else
                {
                    laddersJoinable.Add(ladder, false);
                }

            }

            DataSourceResult result = laddersJoinable.ToDataSourceResult(request, ladder => new PlayerLaddersViewModel
            {
                Id = ladder.Key.Id,
                Name = ladder.Key.Name,
                Status = (bool)ladder.Key.isActive ? "Open" : "Closed",
                Description = ladder.Key.Description,
                Gender = ladder.Key.Gender.Name,
                CreationDate = ladder.Key.CreationDate.ToString("dd MMMM, yyyy"),
                NumPlayersOutofMax = LadderPlayerCollection.LoadByLadder(ladder.Key).Count() + " / " + (ladder.Key.MaxPlayers == 0 ? "unlimited" : ladder.Key.MaxPlayers.ToString()),
                AgeRange = (ladder.Key.MinAge + "-" + ladder.Key.MaxAge) == "0-100" ? "Unrestricted" : (ladder.Key.MinAge + "-" + ladder.Key.MaxAge),
                RatingRange = ladder.Key.MinRating.ToString("0.0") + " - " + ladder.Key.MaxRating.ToString("0.0"),
                UpperChallengeLimit = ladder.Key.UpperChallengeLimit,
                LowerChallengeLimit = ladder.Key.LowerChallengeLimit,
                MaxPendingChallenges = ladder.Key.MaxPendingChallenges,
                MaxQueuedChallenges = ladder.Key.MaxQueuedChallenges,
                MaxInactiveDays = ladder.Key.MaxInactiveDays,

                Penalties = (bool)ladder.Key.Penalties,

                InactivityPointLoss = ladder.Key.InactivityPointLoss,
                MinReqChallenges = ladder.Key.MinReqChallenges,
                MinChallengeDays = ladder.Key.MinChallengeDays,
                MinChallengePointLoss = ladder.Key.MinChallengePointLoss,
                MinReqMatches = ladder.Key.MinReqMatches,
                MinMatchDays = ladder.Key.MinMatchDays,
                MinMatchPointLoss = ladder.Key.MinMatchPointLoss,
                IgnoreAction = ladder.Key.IgnoreAction == null ? null : ((bool)ladder.Key.IgnoreAction ? "Expire" : "Remain as Pending"),
                IgnorePointLoss = ladder.Key.IgnorePointLoss,
                MaxIgnoreDays = ladder.Key.MaxIgnoreDays,
                ChallengeDecline = ladder.Key.ChallengeDecline == null ? null : ladder.Key.ChallengeDecline,
                MaxDeclines = ladder.Key.MaxDeclines,
                DeclineDays = ladder.Key.DeclineDays,
                DeclinePointLoss = ladder.Key.DeclinePointLoss,
                ForfeitPointLoss = ladder.Key.ForfeitPointLoss,

                canJoin = ladder.Value
            });

            return Json(result);
        }
Пример #2
0
        public ActionResult PendingChallenges_Read([DataSourceRequest]DataSourceRequest request)
        {
            /* To get the challenges that the current user is participating in,
             * first find all ChallengePlayer objects associated with that user.
             * Next, loop through the ChallengePlayer objects to get the challenges
             * associated with them.
             */

            //get the current user that is logged in
            string userID = User.Identity.GetUserId();
            int id = System.Convert.ToInt32(userID);
            Users.User user = Users.User.Load(id);

            // get all ChallengePlayer objects for current user
            ChallengePlayerCollection challengePlayers = ChallengePlayerCollection.LoadByPlayer(user);

            //Dictionary for challenges and schedules
            Dictionary<Challenge, SuggestTimeStruct> challengeSchedPairs = new Dictionary<Challenge, SuggestTimeStruct>();

            // get all challenges associated with each challengePlayer object1
            foreach (ChallengePlayer cp in challengePlayers)
            {
                if (cp.Challenge.Status.Status == "pending")
                {
                    ChallengeSchedule mostRecentSchedule = ChallengeScheduleCollection.LoadByChallenge(cp.Challenge).OrderByDescending(s => s.Id).First();
                    bool canSugg = mostRecentSchedule.PlayerId == user.Id ? false : true;
                    SuggestTimeStruct timebool = new SuggestTimeStruct() { SuggestedTime = mostRecentSchedule.SuggestedDateTime, canSuggest = canSugg };
                    challengeSchedPairs.Add(cp.Challenge, timebool);
                }

            }

            DataSourceResult result = challengeSchedPairs.ToDataSourceResult(request, challengeSchedPair => new PendingChallengesViewModel
            {
                challengeId = challengeSchedPair.Key.Id,

                // Only accounting for Singles matches right now. No way to connect pairs for doubles yet
                OpponentName = ChallengePlayerCollection.LoadByChallenge(challengeSchedPair.Key).Where(cp => cp.PlayerId != user.Id).First().Player.FirstName + " " +
                               ChallengePlayerCollection.LoadByChallenge(challengeSchedPair.Key).Where(cp => cp.PlayerId != user.Id).First().Player.LastName,

                LadderName = challengeSchedPair.Key.Ladder.Name,
                FacilityName = challengeSchedPair.Key.Facility.FullName,
                CourtName = challengeSchedPair.Key.Court.Name,
                MatchType = challengeSchedPair.Key.MatchType.Type,
                MatchFormat = challengeSchedPair.Key.MatchFormat.Format,
                SuggestedDateTime = challengeSchedPair.Value.SuggestedTime,
                canSuggest = challengeSchedPair.Value.canSuggest

            });

            return Json(result);
        }
Пример #3
0
        public ActionResult ChallengeablePlayers_Read([DataSourceRequest]DataSourceRequest request, int ladderId)
        {
            // for loading all players that are challengeable within a ladder

            // get user id
            string userID = User.Identity.GetUserId();
            int id = System.Convert.ToInt32(userID);
            Users.User user = Users.User.Load(id);

            bool pendingChallenge = false;

            Ladder ladder = Ladder.LoadById(ladderId);
            // load all ladder players and sort by rank
            IEnumerable<LadderPlayer> ladPlayers = LadderPlayerCollection.LoadByLadder(ladder).OrderBy(lp => lp.PlayerRank);

            LadderPlayer defLadderPlayer = new LadderPlayer()
            {
                PlayerId = -1
            };

            LadderPlayer isPlayerInLadder = LadderPlayerCollection.LoadByLadder(ladder).Where(p => p.PlayerId == user.Id).DefaultIfEmpty(defLadderPlayer).First();

            Dictionary<LadderPlayer, bool> challengeablePlayers = new Dictionary<LadderPlayer, bool>();
            // if player is in the ladder
            if (isPlayerInLadder != defLadderPlayer)
            {

                LadderPlayer userPlayer = LadderPlayerCollection.LoadAll().Where(p => p.PlayerId == user.Id).First();

                IEnumerable<Challenge> allChallenges = ChallengeCollection.LoadByLadder(ladder);
                IEnumerable<ChallengePlayer> ladderChallengePlayers = ChallengePlayerCollection.LoadAll().Where(p => p.Challenge.LadderId == ladder.Id);
                ChallengeCollection userChallenges = new ChallengeCollection();
                ChallengePlayerCollection pendingOpponents = new ChallengePlayerCollection();
                // every challenge in the ladder
                foreach (Challenge challenge in allChallenges)
                {

                    foreach (ChallengePlayer player in ladderChallengePlayers)
                    {
                        if (challenge.Id == player.ChallengeId)
                        {
                            if (challenge.Status.Status == "pending" || challenge.Status.Status == "scheduled")
                            {
                                if (player.Player.Id != user.Id)
                                {
                                    pendingOpponents.Add(player);
                                }
                            }
                        }
                    }

                }
                // if pending challenges is greater than ladder's MaxPendingChallenges
                if (pendingOpponents.Count() < ladder.MaxPendingChallenges)
                {

                    foreach (LadderPlayer ladderOpponent in ladPlayers)
                    {

                        if (userPlayer.PlayerId != ladderOpponent.PlayerId)
                        {

                            if ((ladderOpponent.PlayerRank - userPlayer.PlayerRank) <= ladder.LowerChallengeLimit)
                            {

                                if ((userPlayer.PlayerRank - ladderOpponent.PlayerRank) <= ladder.UpperChallengeLimit)
                                {
                                    // all players currently in the DB are past MaxInactiveDays.. Comment this out to test.
                                    //if ((DateTime.Now - ladderOpponent.Player.LastActivePlayerDate).TotalDays < ladder.MaxInactiveDays)

                                    foreach (ChallengePlayer opponent in pendingOpponents)
                                    {
                                        if (ladderOpponent.PlayerId == opponent.PlayerId)
                                        {
                                            pendingChallenge = true;
                                        }
                                    }
                                    if (!pendingChallenge)
                                    {
                                        challengeablePlayers.Add(ladderOpponent, true);

                                    }
                                    pendingChallenge = false;
                                }

                            }

                        }

                    }

                }

            }

            DataSourceResult result = challengeablePlayers.ToDataSourceResult(request, challengeablePlayer => new LadderPlayersViewModel
            {
                LadderPlayerId = challengeablePlayer.Key.Id,
                PlayerName = challengeablePlayer.Key.Player.FirstName + " " + challengeablePlayer.Key.Player.LastName,
                PlayerPoints = challengeablePlayer.Key.PlayerPoints,
                PlayerRank = challengeablePlayer.Key.PlayerRank,
                ChallengesWon = challengeablePlayer.Key.ChallengesWon,
                ChallengesLost = challengeablePlayer.Key.ChallengesLost,
                DateJoined = challengeablePlayer.Key.DateAdded.ToString("dd MMMM, yyyy")

            });
            return Json(result, JsonRequestBehavior.AllowGet);
        }
Пример #4
0
        public ActionResult CompletedChallenges_Read([DataSourceRequest]DataSourceRequest request)
        {
            /* To get the challenges that the current user is participating in,
             * first find all ChallengePlayer objects associated with that user.
             * Next, loop through the ChallengePlayer objects to get the challenges
             * associated with them.
             */

            // get the current user that is logged in
            string userID = User.Identity.GetUserId();
            int id = System.Convert.ToInt32(userID);
            Users.User user = Users.User.Load(id);

            // get all ChallengePlayer objects for current user
            ChallengePlayerCollection challengePlayers = ChallengePlayerCollection.LoadByPlayer(user);

            Dictionary<Challenge, SetResultCollection> challengesSetResPairs = new Dictionary<Challenge, SetResultCollection>();

            foreach (ChallengePlayer cp in challengePlayers)
            {
                if (cp.Challenge.StatusId == 3) //completed
                {
                    challengesSetResPairs.Add(cp.Challenge, SetResultCollection.LoadByChallenge(cp.Challenge));
                }

            }
            SetResult defaultSR = new SetResult() { SetNum = 0, Score = 0, TieBreak = 0 };
            DataSourceResult result = challengesSetResPairs.ToDataSourceResult(request, challengeSetRes => new CompletedChallengesViewModel
            {
                ChallengeId = challengeSetRes.Key.Id,
                ChallengeName = "Challenge " + challengeSetRes.Key.Id,

                // will need to change for doubles capability
                OpponentName = ChallengePlayerCollection.LoadByChallenge(challengeSetRes.Key)
                                    .Where(cp => cp.PlayerId != user.Id).First().Player.FirstName + " " +
                               ChallengePlayerCollection.LoadByChallenge(challengeSetRes.Key)
                                    .Where(cp => cp.PlayerId != user.Id).First().Player.LastName,

                LadderName = challengeSetRes.Key.Ladder.Name,
                FacilityName = challengeSetRes.Key.Facility.FullName,
                CourtName = challengeSetRes.Key.Court.Name,
                MatchType = challengeSetRes.Key.MatchType.Type,
                MatchFormat = challengeSetRes.Key.MatchFormat.Format,
                numSets = challengeSetRes.Key.MatchFormat.NumSets,
                MatchDateTime = challengeSetRes.Key.MatchDateTime.ToString("dd MMMM yyyy, HH:mm"),

                // will need to change for doubles capability
                PlayerPointsAwarded = ChallengePlayerCollection.LoadByChallenge(challengeSetRes.Key)
                                            .Where(p => p.PlayerId == user.Id).First().PointsAwarded,
                OpponentPointsAwarded = ChallengePlayerCollection.LoadByChallenge(challengeSetRes.Key)
                                            .Where(p => p.PlayerId != user.Id).First().PointsAwarded,

                PlayerSet1Score = challengeSetRes.Value.Where(sr => sr.PlayerId == user.Id).Where(sr => sr.SetNum == 1).DefaultIfEmpty(defaultSR).First().Score,
                PlayerSet2Score = challengeSetRes.Value.Where(sr => sr.PlayerId == user.Id).Where(sr => sr.SetNum == 2).DefaultIfEmpty(defaultSR).First().Score,
                PlayerSet3Score = challengeSetRes.Value.Where(sr => sr.PlayerId == user.Id).Where(sr => sr.SetNum == 3).DefaultIfEmpty(defaultSR).First().Score,
                PlayerSet4Score = challengeSetRes.Value.Where(sr => sr.PlayerId == user.Id).Where(sr => sr.SetNum == 4).DefaultIfEmpty(defaultSR).First().Score,
                PlayerSet5Score = challengeSetRes.Value.Where(sr => sr.PlayerId == user.Id).Where(sr => sr.SetNum == 5).DefaultIfEmpty(defaultSR).First().Score,

                OpponentSet1Score = challengeSetRes.Value.Where(sr => sr.PlayerId != user.Id).Where(sr => sr.SetNum == 1).DefaultIfEmpty(defaultSR).First().Score,
                OpponentSet2Score = challengeSetRes.Value.Where(sr => sr.PlayerId != user.Id).Where(sr => sr.SetNum == 2).DefaultIfEmpty(defaultSR).First().Score,
                OpponentSet3Score = challengeSetRes.Value.Where(sr => sr.PlayerId != user.Id).Where(sr => sr.SetNum == 3).DefaultIfEmpty(defaultSR).First().Score,
                OpponentSet4Score = challengeSetRes.Value.Where(sr => sr.PlayerId != user.Id).Where(sr => sr.SetNum == 4).DefaultIfEmpty(defaultSR).First().Score,
                OpponentSet5Score = challengeSetRes.Value.Where(sr => sr.PlayerId != user.Id).Where(sr => sr.SetNum == 5).DefaultIfEmpty(defaultSR).First().Score,
            });

            return Json(result);
        }
Пример #5
0
        public ActionResult LadderStatus_Read([DataSourceRequest]DataSourceRequest request)
        {
            // for choosing ladder status
            Dictionary<bool, string> statusDict = new Dictionary<bool, string>();
            statusDict.Add(true, "Open");
            statusDict.Add(false, "Closed");

            DataSourceResult result = statusDict.ToDataSourceResult(request, status => new LadderStatusViewModel()
            {
                isActive = status.Key,
                Status = status.Value

            });
            return Json(result.Data, JsonRequestBehavior.AllowGet);
        }
Пример #6
0
        public ActionResult LadderRequests_Read([DataSourceRequest] DataSourceRequest request)
        {
            // loads all players requesting to join a ladder
            Dictionary<Ladder, Users.User> ladderRequests = new Dictionary<Ladder, Users.User>();

            LadderCollection allLadders = LadderCollection.LoadAll();
            foreach (Ladder ladder in allLadders)
            {
                foreach (User user in ladder.Requests)
                {
                    ladderRequests.Add(ladder, user);
                }
            }

            DataSourceResult result = new DataSourceResult();

            result = ladderRequests.ToDataSourceResult(request, ladderRequest => new LadderJoinViewModel
            {
                UserId = ladderRequest.Value.Id,
                FirstName = ladderRequest.Value.FirstName,
                LastName = ladderRequest.Value.LastName,
                PlayerRating = ladderRequest.Value.PlayerRating.Rating,
                LadderId = ladderRequest.Key.Id,
                LadderName = ladderRequest.Key.Name

            });

            return Json(result);
        }
Пример #7
0
        public ActionResult LadderPenalties_Read([DataSourceRequest]DataSourceRequest request)
        {
            // for choosing penalties
            Dictionary<bool, string> penaltiesDict = new Dictionary<bool, string>();
            penaltiesDict.Add(true, "Enabled");
            penaltiesDict.Add(false, "Disabled");

            DataSourceResult result = penaltiesDict.ToDataSourceResult(request, p => new LadderPenaltiesViewModel()
            {
                isPenalties = p.Key,
                Description = p.Value

            });
            return Json(result.Data, JsonRequestBehavior.AllowGet);
        }