public async Task <int> Handle(CreateTournamentFormatCommand request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
if (await this.CheckIfTournamentFormatAlreadyExists(request))
{
throw new EntityAlreadyExistsException(nameof(TournamentFormat), $"{request.Name} - GameId:{request.GameId}");
}
var game = await this.gamesRepository
.AllAsNoTracking()
.SingleOrDefaultAsync(g => g.Id == request.GameId, cancellationToken)
?? throw new NotFoundException(nameof(Game), request.GameId);
var format = new TournamentFormat()
{
Name = request.Name,
Description = request.Description,
TeamPlayersCount = request.TeamPlayersCount,
TotalPlayersCount = request.TeamPlayersCount * TOURNAMENT_FORMAT_PLAYERS_MULTIPLIER,
GameId = game.Id,
};
await this.formatsRepository.AddAsync(format);
await this.formatsRepository.SaveChangesAsync(cancellationToken);
return(format.Id);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] TournamentFormat tournamentFormat)
{
if (id != tournamentFormat.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tournamentFormat);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TournamentFormatExists(tournamentFormat.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tournamentFormat));
}
public async Task GivenWhenICreateATournamentWithTheFollowingDetails(Table table)
{
foreach (TableRow tableRow in table.Rows)
{
CreateGolfClubResponse createGolfClubResponse = this.TestingContext.GetCreateGolfClubResponse(tableRow["GolfClubNumber"]);
List <MeasuredCourseListResponse> measuredCourseList = await this.TestingContext.DockerHelper.GolfClubClient.GetMeasuredCourses(this.TestingContext.GolfClubAdministratorToken,
createGolfClubResponse.GolfClubId,
CancellationToken.None).ConfigureAwait(false);
MeasuredCourseListResponse measuredCourse = measuredCourseList.Single(m => m.Name == tableRow["MeasuredCourseName"]);
TournamentFormat tournamentFormat = Enum.Parse <TournamentFormat>(tableRow["TournamentFormat"], true);
PlayerCategory playerCategory = Enum.Parse <PlayerCategory>(tableRow["PlayerCategory"], true);
// Work out the tournament date
DateTime tournamentDate = this.CalculateTournamentDate(tableRow);
CreateTournamentRequest createTournamentRequest = new CreateTournamentRequest
{
Format = (Int32)tournamentFormat,
Name = tableRow["TournamentName"],
MeasuredCourseId = measuredCourse.MeasuredCourseId,
MemberCategory = (Int32)playerCategory,
TournamentDate = tournamentDate
};
this.TestingContext.CreateTournamentRequests.Add(new Tuple <String, String, String>(tableRow["GolfClubNumber"], tableRow["MeasuredCourseName"],
tableRow["TournamentNumber"]), createTournamentRequest);
}
}
public async Task <ActionResult <TournamentFormat> > PostTournamentFormat(TournamentFormat tournamentFormat)
{
_context.TournamentFormat.Add(tournamentFormat);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTournamentFormat", new { id = tournamentFormat.Id }, tournamentFormat));
}
public async Task <IActionResult> PutTournamentFormat(int id, TournamentFormat tournamentFormat)
{
if (id != tournamentFormat.Id)
{
return(BadRequest());
}
_context.Entry(tournamentFormat).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TournamentFormatExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task SeedAsync(IApplicationDbContext databaseContext, IServiceProvider serviceProvider)
{
var formats = new TournamentFormat[]
{
new TournamentFormat
{
Name = "6v6",
Description = "6v6 is the most common form of competitive format played in Team Fortress 2, and is often viewed as the 'default' format. It is played with 6 players per team, with class limits and weapons bans. The weapon bans and maps vary depending on the specific league.",
TeamPlayersCount = 6,
TotalPlayersCount = 12,
GameId = 1,
CreatedOn = DateTime.UtcNow,
},
new TournamentFormat
{
Name = "9v9",
Description = "Highlander, a form of 9v9, is the largest competitive Team Fortress format. Its similarities to average public servers makes it an ideal starting point for new players, and its requirement that each team has one of every class means no matter what you like to play, there's a spot on the team for you.",
TeamPlayersCount = 9,
TotalPlayersCount = 18,
GameId = 1,
CreatedOn = DateTime.UtcNow
},
new TournamentFormat
{
Name = "5v5",
Description = "Unlike casual mode, competitive mode always pits two teams of 5 against each other in a 30 round match. The roundtime is 1 minute 55 seconds and the bomb timer is 40 seconds. It is not possible to switch sides during the game except at the halftime. After the first 15 rounds, the game reaches halftime and the two teams will switch sides.",
TeamPlayersCount = 5,
TotalPlayersCount = 10,
GameId = 2,
CreatedOn = DateTime.UtcNow
},
};
await databaseContext.AddRangeAsync(formats);
}
public async Task <IActionResult> Create([Bind("Id,Name")] TournamentFormat tournamentFormat)
{
if (ModelState.IsValid)
{
_context.Add(tournamentFormat);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(tournamentFormat));
}
public async Task CreateAsync(string tournamentName, TournamentFormat format)
{
var tournament = _tournamentContext.Tournaments.SingleOrDefault(t => t.Name == tournamentName);
if (tournament != null)
{
//return an error
return;
}
tournament = new Tournament {
Format = format, Name = tournamentName
};
_tournamentContext.Add(tournament);
await _tournamentContext.SaveChangesAsync();
}
public void TournamentAggregate_CreateTournament_InvalidData_ErrorThrown(Boolean validTournamentDate,
Boolean validGolfClubId,
Boolean validMeasuredCourseId,
Int32 measuredCourseSSS,
String name,
PlayerCategory memberCategory,
TournamentFormat tournamentFormat,
Type exceptionType)
{
TournamentAggregate aggregate = TournamentTestData.GetEmptyTournamentAggregate();
DateTime tournamentDate = validTournamentDate ? TournamentTestData.TournamentDate : DateTime.MinValue;
Guid golfClubId = validGolfClubId ? TournamentTestData.GolfClubId : Guid.Empty;
Guid measuredCourseId = validMeasuredCourseId ? TournamentTestData.MeasuredCourseId : Guid.Empty;
Should.Throw(() => { aggregate.CreateTournament(tournamentDate, golfClubId, measuredCourseId, measuredCourseSSS, name, memberCategory, tournamentFormat); },
exceptionType);
}
/// <summary>
/// ドロー表の新しいインスタンスを生成します。
/// </summary>
/// <param name="tournament">大会。</param>
/// <param name="tennisEvent">種目。</param>
/// <param name="tournamentFormat">大会形式。</param>
/// <param name="eligiblePlayersType">出場対象選手の種別。</param>
/// <param name="entryDetails">エントリー詳細の一覧。</param>
/// <param name="mainDrawSettings">本戦のドロー設定。</param>
/// <param name="qualifyingDrawSettings">予選のドロー設定。</param>
/// <param name="blocks">ブロックの一覧。</param>
/// <param name="editStatus">編集状態。</param>
public DrawTable(
Tournament tournament,
TennisEvent tennisEvent,
TournamentFormat tournamentFormat,
EligiblePlayersType eligiblePlayersType,
List <EntryDetail> entryDetails,
DrawSettings mainDrawSettings,
DrawSettings qualifyingDrawSettings,
IEnumerable <Block> blocks,
EditStatus editStatus)
{
this.TournamentId = tournament.Id;
this.TennisEventId = tennisEvent.TennisEventId;
this.TournamentFormat = tournamentFormat;
this.EligiblePlayersType = eligiblePlayersType;
this.EntryDetails = new EntryDetails(entryDetails);
this.MainDrawSettings = mainDrawSettings;
this.QualifyingDrawSettings = qualifyingDrawSettings;
this.Blocks = new Blocks(blocks);
this.EditStatus = editStatus;
}
/// <summary>
/// ドロー設定ビューモデルの新しいインスタンスを生成します。
/// </summary>
/// <param name="tournamentId">大会 ID。</param>
/// <param name="tournamentName">大会名。</param>
/// <param name="tennisEventId">種目 ID。</param>
/// <param name="tennisEvent">種目。</param>
/// <param name="drawTable">ドロー表。</param>
public SettingsViewModel(
string tournamentId,
string tournamentName,
string tennisEventId,
string tennisEvent,
DrawTable drawTable)
{
this.TournamentId = tournamentId;
this.TournamentName = tournamentName;
this.TennisEventId = tennisEventId;
this.TennisEvent = tennisEvent;
this.DrawTable = drawTable;
this.TournamentFormat = drawTable.TournamentFormat;
this.ShowQualifyingDrawSettings = this.TournamentFormat == TournamentFormat.WithQualifying;
this.MainNumberOfDraws = this.CreateNumberOfDraws(ParticipationClassification.Main);
this.MainNumberOfEntries = $"{this.GetNumberOfEntries(ParticipationClassification.Main)}";
this.MainTournamentGrades = this.CreateTournamentGrades(ParticipationClassification.Main);
this.QualifyingNumberOfDraws = this.CreateNumberOfDraws(ParticipationClassification.Qualifying);
this.QualifyingNumberOfEntries = $"{this.GetNumberOfEntries(ParticipationClassification.Qualifying)}";
this.QualifyingTournamentGrades = this.CreateTournamentGrades(ParticipationClassification.Qualifying);
this.EnteredQualifyingNumberOfBlocks = this.GetInitialQualifyingNumberOfBlocks();
}
