// GET: CreateTournament public ActionResult CreateTournament() { CreateTournamentViewModel tournamentViewModel = new CreateTournamentViewModel(); tournamentViewModel.TournamentTypes = tournamentLogic.GetTournamentTypeList(); return(View(tournamentViewModel)); }
public CreateTournamentViewModel WithDefaultValues() { _createTournamentViewModel = new CreateTournamentViewModel() { MoviesIds = MoviesIds }; return(_createTournamentViewModel); }
// POST: SubmitTournament public ActionResult SubmitTournament(CreateTournamentViewModel tournamentViewModel) { //save tournament and see the tournament page if (ModelState.IsValid) { tournamentLogic.SaveTournament(tournamentViewModel); } return(View()); }
/// <summary> /// Creates the tournament. /// </summary> /// <param name="accessToken">The access token.</param> /// <param name="claimsIdentity">The claims identity.</param> /// <param name="viewModel">The view model.</param> /// <param name="cancellationToken">The cancellation token.</param> public async Task CreateTournament(String accessToken, ClaimsIdentity claimsIdentity, CreateTournamentViewModel viewModel, CancellationToken cancellationToken) { CreateTournamentRequest request = this.ModelFactory.ConvertFrom(viewModel); Guid golfClubId = ApiClient.GetClaimValue <Guid>(claimsIdentity, "GolfClubId"); await this.TournamentClient.CreateTournament(accessToken, golfClubId, request, cancellationToken); }
/// <summary> /// Converts from. /// </summary> /// <param name="viewModel">The view model.</param> /// <returns></returns> public CreateTournamentRequest ConvertFrom(CreateTournamentViewModel viewModel) { CreateTournamentRequest request = new CreateTournamentRequest { Format = viewModel.Format, MemberCategory = viewModel.MemberCategory, MeasuredCourseId = viewModel.MeasuredCourseId, TournamentDate = viewModel.TournamentDate.Value, Name = viewModel.Name }; return(request); }
public void ModelFactory_ConvertFrom_CreateTournamentViewModel_ConvertedSuccessfully() { ModelFactory factory = new ModelFactory(); CreateTournamentViewModel viewModel = ModelFactoryTestData.GetCreateTournamentViewModel(); CreateTournamentRequest apiRequest = factory.ConvertFrom(viewModel); apiRequest.Format.ShouldBe(viewModel.Format); apiRequest.MeasuredCourseId.ShouldBe(viewModel.MeasuredCourseId); apiRequest.MemberCategory.ShouldBe(viewModel.MemberCategory); apiRequest.Name.ShouldBe(viewModel.Name); apiRequest.TournamentDate.ShouldBe(viewModel.TournamentDate.Value); }
public async Task <IActionResult> CreateTournament(CreateTournamentViewModel model, CancellationToken cancellationToken) { // Validate the model if (this.ValidateModel(model)) { String accessToken = await this.HttpContext.GetTokenAsync("access_token"); // All good with model, call the client to create the golf club await this.ApiClient.CreateTournament(accessToken, this.User.Identity as ClaimsIdentity, model, cancellationToken); // Tournament Created, redirect to the Manage Tournaments screen return(this.RedirectToAction(nameof(this.GetTournamentList))); } // If we got this far, something failed, redisplay form return(this.View(model)); }
public async Task <IActionResult> CreateTournament(CreateTournamentViewModel model) { var currentUser = await userManager.GetUserAsync(User); TournamentDTO tournamentDTO = new TournamentDTO() { Name = model.Name, OrganisationID = model.OrganisationID, UserID = currentUser.Id, Size = model.Size, Prize = model.Prize, BuyIn = model.BuyIn, Game = model.Game, StartTime = model.StartTime, TeamSize = model.TeamSize }; var result = tournamentManager.CreateTournament(tournamentDTO); ViewData["Creator"] = model.OrganisationID == "null" ? "User" : "Org"; ViewData["OrgName"] = model.OrganisationID == "null" ? null : organisationManager.GetOrganisationByID(model.OrganisationID).Name; ViewData["UserName"] = currentUser.UserName; switch (result) { case TournamentManagerErrorCodes.NoError: return(RedirectToAction("Index")); case TournamentManagerErrorCodes.BuyInMoreOrEqualToPrize: ModelState.AddModelError("BuyIn", "Buy In can't be less or equal to prize!"); return(View(model)); case TournamentManagerErrorCodes.NoHost: return(RedirectToAction("Error", "Home", new { errorMessage = "There was no Host assigned to the tournament!", errorDate = DateTime.Now })); case TournamentManagerErrorCodes.NotEnoughMoney: ModelState.AddModelError("Prize", "You don't have enough currency to create a tournament with such a prize pool!"); return(View(model)); case TournamentManagerErrorCodes.UnexpectedError: default: return(RedirectToAction("Error", "Home", new { errorMessage = "An Unknown error occured while creating a tournament", errorDate = DateTime.Now })); } }
public async Task <Response <string> > CreateAsync(CreateTournamentViewModel model) { var moviesResponse = await _movieService.GetMoviesAsync(); if (!moviesResponse.Success) { return(new Response <string>(moviesResponse.Success, moviesResponse.Message)); } var moviesSelected = moviesResponse.Data.Where(m => model.MoviesIds.Contains(m.Id)); if (moviesSelected.Count() != 8) { return(new Response <string>(false, "Error creating the tournament. Invalid movies Ids.")); } var tournament = new Tournament(_mapper.Map <IEnumerable <Movie> >(moviesSelected)); await _repository.InsertOneAsync(tournament); var standing = await _standingService.CreateAsync(tournament); return(new Response <string>(true, "Successfully created tournament", standing.Id)); }
/// <summary> /// Save your Tournament! /// </summary> /// <param name="tournamentViewModel"></param> public void SaveTournament(CreateTournamentViewModel tournamentViewModel) { tournament newTournament = new tournament { tournament_name = tournamentViewModel.TournamentName, tournament_type_id = tournamentViewModel.TournamentType, //TODO: user id tournament_host_id = 1, number_participants = tournamentViewModel.Participants.Count }; UnitOfWork.TournamentRepository.InsertAndSave(newTournament); var allParticipants = UnitOfWork.ParticipantRepository.All(); var participantList = new List <participant>(); //save the new participants foreach (var participantName in tournamentViewModel.Participants) { var participantExist = allParticipants.Where(x => x.participant_name == participantName).FirstOrDefault(); if (participantExist == null) { var newParticipant = new participant { participant_name = participantName }; UnitOfWork.ParticipantRepository.InsertAndSave(newParticipant); participantExist = newParticipant; } participantList.Add(participantExist); var tournament_participant = new tournament_participant_rel { tournament_id = newTournament.tournament_id, participant_id = participantExist.participant_id }; UnitOfWork.Tournament_participant_RelRepository.InsertAndSave(tournament_participant); } GenerateCompetition(participantList, newTournament); }
public async Task <IActionResult> CreateTournament(string OrganisationID) { var currentUser = await userManager.GetUserAsync(User); if (OrganisationID == null && currentUser == null) { return(RedirectToAction("Register", "Account")); } ViewData["Creator"] = OrganisationID == null ? "User" : "Org"; CreateTournamentViewModel model = new CreateTournamentViewModel() { OrganisationID = OrganisationID == null ? "null" : OrganisationID, UserID = currentUser == null ? "null" : currentUser.Id }; ViewData["OrgName"] = OrganisationID == null ? null : organisationManager.GetOrganisationByID(OrganisationID).Name; ViewData["UserName"] = currentUser.UserName; model.StartTime = DateTime.Now; return(View(model)); }
public async Task <IActionResult> CreateTournament(CancellationToken cancellationToken) { CreateTournamentViewModel viewModel = new CreateTournamentViewModel(); return(this.View(viewModel)); }
/// <summary> /// Validates the model. /// </summary> /// <param name="model">The model.</param> /// <returns></returns> private Boolean ValidateModel(CreateTournamentViewModel model) { return(this.ModelState.IsValid); }
public CreateTournamentViewModelBuilder() { _createTournamentViewModel = WithDefaultValues(); }
public async Task <ActionResult <Response <TournamentViewModel> > > PostAsync([FromBody] CreateTournamentViewModel model) { var response = await _service.CreateAsync(model); if (response.Success) { return(Created(nameof(PostAsync), response)); } return(BadRequest(response)); }
public ActionResult RemoveParticipant(CreateTournamentViewModel tournamentViewModel, string participantName) { tournamentViewModel.Participants.Remove(participantName); ModelState.Clear(); return(PartialView("~/Views/Tournament/Partial/_ParticipantTable.cshtml", tournamentViewModel)); }