private void LoadStoredTournaments()
{
var settings = new UserSettings();
var tournaments = _tournamentRepository.ReadXml(settings.TournamentXMLFilename);
_tournamentRepository.Add(tournaments);
Tournaments = _tournamentRepository.GetAll();
}
public IActionResult Post([FromBody] Tournament tournament)
{
try
{
if (tournament != null)
{
_logger.LogInformation("API Request hit: INSERT Tournament : " + tournament.Name);
var result = _tournamentRepository.Add(tournament);
if (result == 0)
{
return(Ok("{\"status\": \"Success\"}"));
}
else
{
_logger.LogInformation("API Request (INSERT Tournament : " + tournament.Name + " ) not committed");
return(NotFound("Failed: INSERT could not commit"));
}
}
else
{
_logger.LogInformation("API Request hit (INSERT Tournament) with null entry");
return(BadRequest("Failed: null entry"));
}
}
catch (Exception e)
{
_logger.LogError("API Request (INSERT Tournament) FAILED: ", e);
return(BadRequest("Failed"));
}
}
public IActionResult CreateTournament(TournamentCreateViewModel model)
{
if (ModelState.IsValid)
{
string uniqueFileName1 = ProcessUploadFile(model.Image1);
string uniqueFileName2 = ProcessUploadFile(model.Image2);
Tournament newTournament = new Tournament {
Name = model.Name,
Email = model.Email,
CityId = model.CityId,
Description = model.Description,
SportId = model.SportId,
Phone = model.Phone,
PriceParticipation = model.PriceParticipation,
PricePerGame = model.PricePerGame,
IsPayed = model.IsPayed,
Image1Path = uniqueFileName1,
Image2Path = uniqueFileName2
};
tournamentRepository.Add(newTournament);
return(RedirectToAction("Details", "Tournament", new { id = newTournament.Id }));
}
var tournament = new TournamentCreateViewModel {
Cities = sportObjectRepository.GetAllCities(),
Sports = sportObjectRepository.GetAllSports()
};
return(View("CreateTournament", tournament));
}
public ActionResult <Tournament> AddTournament(Tournament tournament)
{
_tournamentRepository.Add(tournament);
_tournamentRepository.SaveChanges();
return(CreatedAtAction(nameof(GetTournament), new { id = tournament.TournamentId }, tournament));
}
public IHttpActionResult Post([FromBody] Tournament tournament)
{
var result = new Tournament();
if (ModelState.IsValid)
{
if (tournament.Organizer == null)
{
return(Content(HttpStatusCode.BadRequest, "Organizer is empty"));
}
if (tournament.Organizer.Id == 0 || organizerRepository.Get(tournament.Organizer.Id) == null)
{
return(Content(HttpStatusCode.NotFound, "Organizer not found"));
}
if (tournament.Venue == null)
{
return(Content(HttpStatusCode.BadRequest, "Venue is empty"));
}
if (tournament.Venue.Id == 0 || venueRepository.Get(tournament.Venue.Id) == null)
{
return(Content(HttpStatusCode.NotFound, "Venue not found"));
}
result = tournamentRepository.Add(tournament);
}
return(Json(result));
}
public Tournament AddTournament(TournamentForCreationDto tournament)
{
var tournamentEntity = mapper.Map <Tournament>(tournament);
tournamentRepository.Add(tournamentEntity);
tournamentRepository.SaveChanges();
var tournamentToReturn = mapper.Map <Tournament>(tournamentEntity);
return(tournamentToReturn);
}
public IActionResult CreateTournament([FromBody] TournamentDto value)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var tournament = tournamentRepository.Add(value);
return(Ok(tournament.ToTournamentDto()));
}
public async Task Add_ABCTournament()
{
//Arrange
var tournament = new TournamentDto()
{
Caption = "ABCTournament",
EndDate = DateTime.Now.AddDays(1),
StartDate = DateTime.Now
};
//Act
await _tournamentRepository.Add(tournament);
await _tournamentRepository.SaveChanges();
//Assert
Assert.NotNull(tournament);
Assert.Greater(tournament.Id, 1);
Assert.AreEqual("ABCTournament", tournament.Caption);
}
public async Task HandleAsync(AddTournament command)
{
var newTournament = new TournamentDto()
{
Caption = command.Caption,
Description = command.Description,
EndDate = command.EndDate,
StartDate = command.StartDate
};
await _tournamentRepository.Add(newTournament);
await _tournamentRepository.SaveChanges();
}
public void CreateTournament(Tournament tournament, string uri)
{
int countOfTournamentKeys = ValidateTournament(tournament);
if (countOfTournamentKeys > 0)
{
tournament = _matchModel.CreateGenerateMatches(tournament);
_tournamentRepository.Add(tournament, uri);
}
else
{
}
}
public IActionResult Post([FromBody] Tournament tournament)
{
if (tournament == null)
{
return(BadRequest("Tournament is null."));
}
_tournamentRepository.Add(tournament);
return(CreatedAtRoute(
"TournamentGet",
new { Id = tournament.TournamentID },
tournament));
}
public void CreateTournament(Tournament tournament, string uri)
{
int countOfTournamentKeys = ValidateTournament(tournament);
if (countOfTournamentKeys > 0)
{
tournament.NumberOfKeys = countOfTournamentKeys;
Tournament tournamentWithKeys = CreateKeys(tournament);
_tournamentRepository.Add(tournamentWithKeys, uri);
}
else
{
}
}
public async Task AddNewTournamentAsync(Tournament tournament)
{
var user = await userRepository.GetByIdAsync(tournament.CreatorId) ??
throw new NotFoundInDatabaseException();
var tournamentToAdd = await tournamentRepository.FindSingleAsync(x => x.Name == tournament.Name);
if (tournamentToAdd != null)
{
throw new AlreadyInDatabaseException();
}
tournamentRepository.Add(tournament);
await unitOfWork.CompleteAsync();
}
/// <summary>
/// Create a new tournament
/// </summary>
/// <param name="tournamentToCreate">A Tournament to create</param>
public void Create(Tournament tournamentToCreate)
{
_authService.CheckAccess(AuthOperations.Tournaments.Create);
if (tournamentToCreate == null)
{
throw new ArgumentNullException("tournamentToCreate");
}
ValidateTournament(tournamentToCreate);
ValidateDivisions(tournamentToCreate.Divisions);
ValidateGroups(tournamentToCreate.Divisions);
tournamentToCreate.LastTimeUpdated = TimeProvider.Current.UtcNow;
_tournamentRepository.Add(tournamentToCreate);
_tournamentRepository.UnitOfWork.Commit();
}
public TournamentDto CreateTournament(IEnumerable <string> playerNames)
{
Tournament tournament = _tournamentRepository.Add(new Tournament());
// TODO: Check # of players?
foreach (string name in playerNames)
{
_playerRepository.Add(new Player(name, tournament.Id));
}
if (playerNames.Count() % 2 != 0)
{
_playerRepository.Add(new Player("BYE", tournament.Id));
}
_unitOfWork.Commit();
StartTournament(tournament);
return(_mapper.Map <TournamentDto>(tournament));
}
public void Initialize()
{
string tournamentIdA = Guid.NewGuid().ToString();
string tournamentIdB = Guid.NewGuid().ToString();
string teamBlueId = Guid.NewGuid().ToString();
string teamWhiteId = Guid.NewGuid().ToString();
string matchId = Guid.NewGuid().ToString();
tournamentA = new Tournament
{
Date = new DateTime(2015, 5, 5),
MaxPlayerPerTeam = 8,
TotalTeam = 4,
Id = tournamentIdA
};
tournamentB = new Tournament
{
Date = new DateTime(2015, 5, 5),
MaxPlayerPerTeam = 8,
TotalTeam = 4,
Id = tournamentIdB
};
blue = new Team {
Name = "Blue", Id = teamBlueId
};
white = new Team {
Name = "White", Id = teamWhiteId
};
match = new Match {
HomeTeam = blue, AwayTeam = white, TournamentId = tournamentIdA
};
tournamentRepo = A.Fake <ITournamentRepository>();
A.CallTo(() => tournamentRepo.GetAll())
.Returns(new List <TournamentDto> {
new TournamentDto
{
Date = DateTime.Now,
MaxPlayerPerTeam = 6,
TotalTeam = 4
},
new TournamentDto
{
Date = DateTime.Now.AddDays(2),
TotalTeam = 5,
MaxPlayerPerTeam = 10
}
});
A.CallTo(() => tournamentRepo.GetByDate(new DateTime(2015, 1, 1)))
.Returns(new TournamentDto
{
Id = "1",
Date = new DateTime(2015, 1, 1),
MaxPlayerPerTeam = 6,
TotalTeam = 4
});
A.CallTo(() => tournamentRepo.GetTeamsByTournament(tournamentIdA))
.Returns(new List <TeamDto>
{
blue.ConvertToDto(),
white.ConvertToDto()
});
A.CallTo(() => tournamentRepo.GetTeamsByTournament("2"))
.Returns(new List <TeamDto>
{
blue.ConvertToDto(),
white.ConvertToDto()
});
A.CallTo(() => tournamentRepo.GetTotalTeamsByTournament(tournamentIdA))
.Returns(5);
A.CallTo(() => tournamentRepo.GetTotalTeamsByTournament("2"))
.Returns(3);
A.CallTo(() => tournamentRepo.GetMatches(tournamentIdA))
.Returns(new List <MatchDto>
{
match.ConvertToDto()
});
A.CallTo(() => tournamentRepo.GetPlayersByTeam(tournamentIdA, teamBlueId))
.Returns(new List <PlayerDto>
{
new PlayerDto {
Id = "3", Name = "Ali"
},
new PlayerDto {
Id = "4", Name = "Rafiq"
},
new PlayerDto {
Id = "5", Name = "Nathan"
},
new PlayerDto {
Id = "6", Name = "Jon"
},
new PlayerDto {
Id = "7", Name = "Bass"
},
new PlayerDto {
Id = "8", Name = "Geoff"
}
});
A.CallTo(() => tournamentRepo.GetPlayerById("3"))
.Returns(new PlayerDto
{
Id = "3",
Name = "Ali"
});
A.CallTo(() => tournamentRepo.Add(tournamentA.ConvertToDto()))
.Returns <string>(tournamentIdA);
tournamentService = new TournamentService(tournamentRepo);
}
public Task <Response <TournamentDTO> > Handle(CreateTournamentCommand request, CancellationToken cancellationToken)
{
return(Task.FromResult(Response.Ok(repository.Add(request))));
}
public async Task Add(Tournament tournament)
{
await _tournamentRepository.Add(tournament);
await _tournamentRepository.SaveChanges();
}
public Tournament Add(Tournament tournament)
{
return(_tournamentRepository.Add(tournament));
}
public void AddTournament(Tournament tournament)
{
_tournamentRepository.Add(tournament);
}
public Tournament CreateTournament(Tournament tournament)
{
return(_tournamentRepository.Add(tournament));
}
public string CreateTournament(Tournament tournament)
{
var tournamentId = tournamentRepo.Add(tournament.ConvertToDto());
return(tournamentId);
}