Esempio n. 1
0
        //
        // GET: /Draft/Details/5
        public ActionResult Details(int id)
        {
            DraftViewModel dvm = GetDraftViewModel(id);

            if (dvm == null)
            {
                return(RedirectToAction("Index"));
            }

            var member = GetAuthorizedMember();

            if (member != null)
            {
                using (var sl = new SystemLogic())
                {
                    dvm.IsMemberOfDraft = sl.IsMemberOfDraft(member.Id, id);
                }
            }

            if (Request.IsAjaxRequest())
            {
                return(Json(dvm, JsonRequestBehavior.AllowGet));
            }

            return(View(dvm));
        }
Esempio n. 2
0
        public ActionResult Pick(string cardName, int draftId)
        {
            var authMember = GetAuthorizedMember();

            using (var sl = new SystemLogic())
            {
                if (!sl.IsMemberOfDraft(authMember.Id, draftId))
                {
                    return(RedirectToAction("Index"));
                }

                var draftLogic = GetDraftLogic.FromDraftId(draftId);
                var card       = sl.GetCard(cardName);

                if (card == null)
                {
                    var likeList = sl.FindCard(cardName);
                    return(Json(new { pickresult = false, reason = "Card was not found!", alternatives = likeList }));
                }

                var pickSuccess = draftLogic.PickCard(draftId, authMember.Id, card.Id);

                if (!pickSuccess)
                {
                    return(Json(new { pickresult = false, reason = "Card was already picked, try another card!" }));
                }

                DraftViewModel dvm = GetDraftViewModel(draftId);

                return(Json(new { pickresult = true, updatedDvm = dvm }));
            }
        }
        //GET: FantasyLeagues/Draft/5
        public async Task <IActionResult> Draft(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            if (!_service.DraftExists(id.Value))
            {
                await _service.CreateDraft(id.Value);

                DraftViewModel viewModel = new DraftViewModel()
                {
                    Draft            = await _service.GetDraft(id.Value),
                    AvailablePlayers = new SelectList(await _service.GetDraftPlayers(id.Value), "Value", "Text"),
                    Team             = await _mService.GetTeamByOwnerID(User.FindFirst(ClaimTypes.NameIdentifier).Value)
                };
                return(View(viewModel));
            }
            else
            {
                DraftViewModel viewModel = new DraftViewModel()
                {
                    Draft            = await _service.GetDraft(id.Value),
                    AvailablePlayers = new SelectList(await _service.GetDraftPlayers(id.Value), "Value", "Text"),
                    Team             = await _mService.GetTeamByOwnerID(User.FindFirst(ClaimTypes.NameIdentifier).Value)
                };
                return(View(viewModel));
            }
        }
Esempio n. 4
0
        public async Task <IActionResult> MakeSoloDraft()
        {
            var champion = await this.championService.GetRandomChampionAsync();

            var build = await this.itemService.GetRandomBuildAsync();

            var position = await this.positionService.GetRandomPositionAsync();

            var summonerSpells = await this.summonerSpellService.GetRandomSummonerSpellsAsync();

            if (PositionConstants.Jungle.Equals(position.Name))
            {
                build = await this.itemService.GetRandomJungleBuildAsync();

                summonerSpells = await this.summonerSpellService.GetJunglerSummonerSpellsAsync();
            }
            else if (PositionConstants.Support.Equals(position.Name))
            {
                build = await this.itemService.GetRandomSupportBuildAsync();
            }

            var draftViewModel = new DraftViewModel()
            {
                Champion       = champion,
                Build          = build,
                Position       = position,
                SummonerSpells = summonerSpells
            };

            return(this.View(draftViewModel));
        }
Esempio n. 5
0
        public async Task <IActionResult> SaveDraft([FromBody] DraftViewModel model)
        {
            var command = new SaveDraftCommand
            {
                UserId     = HttpContext.GetLoggedUserId(),
                Content    = model.Content,
                QuestionId = model.QuestionId
            };
            var response = await _mediator.Send(command);

            return(Ok(BaseResponse.Ok(response.Message)));
        }
Esempio n. 6
0
        public ActionResult Index()
        {
            DraftViewModel model = null;

            try {
                DraftUser user = DraftAuthentication.AuthenticateRequest(HttpContext.Request);
                model = new DraftViewModel(user);
            } catch (DraftAuthenticationException)
            {
                return(RedirectToAction("Index", "Login"));
            }

            return(View(model));
        }
        public async Task ThenViewIsReturned(
            [Frozen] Mock <IModelMapper> modelMapper,
            CohortsByAccountRequest request,
            DraftViewModel viewModel,
            CohortController controller)
        {
            modelMapper
            .Setup(x => x.Map <DraftViewModel>(request))
            .ReturnsAsync(viewModel);

            var result = await controller.Draft(request) as ViewResult;

            Assert.NotNull(result);
            Assert.AreEqual(result.Model, viewModel);
        }
Esempio n. 8
0
        public WhenGettingCohortsFixture()
        {
            Request                     = new CohortsByProviderRequest();
            ModelMapperMock             = new Mock <IModelMapper>();
            CohortsViewModel            = new CohortsViewModel();
            ReviewViewModel             = new ReviewViewModel();
            DraftViewModel              = new DraftViewModel();
            WithTransferSenderViewModel = new WithTransferSenderViewModel();

            ModelMapperMock.Setup(x => x.Map <CohortsViewModel>(Request)).ReturnsAsync(CohortsViewModel);
            ModelMapperMock.Setup(x => x.Map <ReviewViewModel>(Request)).ReturnsAsync(ReviewViewModel);
            ModelMapperMock.Setup(x => x.Map <DraftViewModel>(Request)).ReturnsAsync(DraftViewModel);
            ModelMapperMock.Setup(x => x.Map <WithTransferSenderViewModel>(Request)).ReturnsAsync(WithTransferSenderViewModel);

            Sut = new CohortController(Mock.Of <IMediator>(), ModelMapperMock.Object, Mock.Of <ILinkGenerator>(), Mock.Of <ICommitmentsApiClient>());
        }
        public IActionResult Draft(int id)
        {
            DraftViewModel draftViewModel = new DraftViewModel();
            var            userId         = _userManager.GetUserId(User);

            Draft draft            = _draftService.GetDraft(id);
            Team  userTeam         = _teamService.GetUserTeam(draft);
            Team  availablePlayers = _teamService.GetAvailablePlayers(draft);

            draftViewModel.LeagueName       = draft.LeagueName;
            draftViewModel.TeamName         = userTeam.TeamName;
            draftViewModel.DraftPosition    = draft.UserDraftPosition;
            draftViewModel.NumberOfTeams    = draft.NumberOfTeams;
            draftViewModel.MyPlayers        = userTeam.Players.ToHashSet();
            draftViewModel.AvailablePlayers = availablePlayers.Players.ToHashSet();

            int pick = _draftService.GetPick(draft);

            draftViewModel.pick  = pick;
            draftViewModel.round = _draftService.GetRound(pick, draft.NumberOfTeams);

            return(View(draftViewModel));
        }
Esempio n. 10
0
        private DraftViewModel GetDraftViewModel(int draftId)
        {
            var draftLogic  = GetDraftLogic.FromDraftId(draftId);
            var systemLogic = new SystemLogic();

            if (!draftLogic.IsDraftAvailable(draftId))
            {
                return(null);
            }

            var draft = systemLogic.GetDraftById(draftId);

            using (var sl = new SystemLogic())
            {
                var picks = systemLogic.GetPickList(draftId);
                var dvm   = new DraftViewModel
                {
                    Id = draftId,
                    MaximumNumberOfPicks = draft.MaximumPicksPerMember,
                    Name                 = draft.Name,
                    Owner                = sl.GetMember(draft.Owner.Id).FullName,
                    CreationDate         = draft.CreatedDate,
                    CurrentPickPosition  = draftLogic.CurrentPickPosition(draftId),
                    CurrentNumberOfPicks = picks.Count
                };

                var members = systemLogic.GetDraftMembers(draftId);

                foreach (var draftMemberPositions in members)
                {
                    var member        = sl.GetMember(draftMemberPositions.Member.Id);
                    var draftMemberVm = new DraftMemberVm
                    {
                        DisplayName = member.FullName,
                        Id          = member.Id,
                    };

                    dvm.Members.Add(draftMemberVm);
                }

                var pickCount  = picks.Count;
                var startIndex = pickCount - draft.DraftSize;
                if (startIndex < 0)
                {
                    startIndex = 0;
                }

                for (int i = startIndex; i < pickCount; i++)
                {
                    var pick = picks[i];

                    var member = sl.GetMember(pick.Member.Id);
                    var card   = sl.GetCard(pick.Card.Id);

                    var pvm = new PickViewModel {
                        CardId = pick.Card.Id, MemberId = pick.Member.Id, PickTime = PickTime.History, CardName = card.Name, MemberName = member.FullName
                    };
                    dvm.Picks.Add(pvm);
                }

                var currentPick = new PickViewModel()
                {
                    MemberId   = draft.CurrentTurn.Id,
                    MemberName = sl.GetMember(draft.CurrentTurn.Id).FullName,
                    PickTime   = PickTime.Current,
                };
                dvm.Picks.Add(currentPick);

                for (int i = 0; i < draft.DraftSize; i++)
                {
                    var nextDraftPosition = draftLogic.GetNextPickPosition(pickCount + 1 + i, draft.DraftSize);
                    var nextMember        = dvm.Members[nextDraftPosition - 1];
                    var nextPick          = new PickViewModel
                    {
                        MemberName = nextMember.DisplayName,
                        MemberId   = nextMember.Id,
                        PickTime   = PickTime.Future
                    };

                    dvm.Picks.Add(nextPick);
                }

                var authMember = GetAuthorizedMember();
                if (authMember != null)
                {
                    foreach (FuturePick fp in sl.GetMyFuturePicks(draftId, authMember.Id))
                    {
                        Card card = sl.GetCard(fp.Card.Id);
                        dvm.FuturePicks.Add(card.Name);
                    }
                }

                return(dvm);
            }
        }
        public ActionResult New()
        {
            DraftViewModel model = new DraftViewModel();

            return(View(model));
        }
Esempio n. 12
0
        public async Task <WhenMappingDraftRequestToViewModelFixture> Map()
        {
            DraftViewModel = await Mapper.Map(DraftRequest);

            return(this);
        }
 public WhenMappingDraftRequestToViewModelFixture Map()
 {
     DraftViewModel = Mapper.Map(DraftRequest).Result;
     return(this);
 }