コード例 #1
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);
        }
コード例 #2
0
        public ActionResult LadderRequests_Accept(int ladderId, int userId)
        {
            // for accepting a players request to join a ladder
            if (userId > 0 && ladderId > 0) //0 is default if there is null passed for some reason
            {
                Users.User user = Users.User.Load(userId);
                Ladder ladder = Ladder.Load(ladderId);

                LadderPlayer ladderPlayer = new LadderPlayer();
                ladderPlayer.LadderId = ladderId;
                ladderPlayer.PlayerId = userId;
                ladderPlayer.ChallengesLost = 0;
                ladderPlayer.ChallengesWon = 0;
                ladderPlayer.DateAdded = DateTime.UtcNow;
                ladderPlayer.PreviousPoints = 0;
                ladderPlayer.PlayerPoints = LadderPointsCollection.LoadByLadder(ladder)
                                                .Where(p => p.RatingId == user.PlayerRatingId)
                                                .FirstOrDefault()
                                                .NumStartingPoints;
                ladderPlayer.Save();

                UpdateRankings(ladder);

                user.Requests.Remove(ladder);
                ladder.Requests.Remove(user);

                user.Save();
                ladder.Save();

                // email notification
                var email = new NewNotificationEmail
                {
                    To = user.Email,
                    FirstName = user.FirstName,
                    NotificationMessage = ("Congratulations, your request to join " + ladder.Name + " ladder has been Accepted!")
                };

                email.Send();

                return RedirectToAction("Home", "Admin");
            }
            return RedirectToAction("Home", "Admin");
        }