// 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));
}
