public async Task <int> Handle(CreateMatchCommand request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
if (!await CommonCheckHelper.CheckIfTeamExists(request.HomeTeamId, this.teamsRepository))
{
throw new NotFoundException(nameof(Team), request.HomeTeamId);
}
if (!await CommonCheckHelper.CheckIfTeamExists(request.AwayTeamId, this.teamsRepository))
{
throw new NotFoundException(nameof(Team), request.AwayTeamId);
}
if (await this.CheckIfTeamIsDropped(request.HomeTeamId, request.PlayWeekId) ||
await this.CheckIfTeamIsDropped(request.AwayTeamId, request.PlayWeekId))
{
throw new ForbiddenException();
}
var match = new Match
{
HomeTeamId = request.HomeTeamId,
AwayTeamId = request.AwayTeamId,
ScheduledDate = request.PlayDate,
PlayWeekId = request.PlayWeekId
};
await this.matchesRepository.AddAsync(match);
await this.matchesRepository.SaveChangesAsync(cancellationToken);
return(match.Id);
}
public async Task <int> Handle(AddPlayerCommand request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
var desiredTeam = await this.teamsRepository
.All()
.Include(t => t.PlayerTeams)
.SingleOrDefaultAsync(t => t.Id == request.TeamId, cancellationToken)
?? throw new NotFoundException(nameof(Team), request.TeamId);
if (await CommonCheckHelper.CheckIfTeamIsFull(desiredTeam.Id, this.teamsRepository))
{
throw new TeamIsFullException(desiredTeam.Name);
}
if (this.CheckIfPlayerParticipatesInATeamWithTheSameFormat(desiredTeam.TournamentFormatId, request.PlayerId))
{
throw new PlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException();
}
desiredTeam.PlayerTeams.Add(new PlayerTeam {
PlayerId = request.PlayerId
});
return(await this.teamsRepository.SaveChangesAsync(cancellationToken));
}
public async Task <int> Handle(EnrollATeamCommand request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
if (!await CommonCheckHelper.CheckIfPlayerExists(this.userAccessor.UserId, this.playersRepository))
{
throw new NotFoundException(nameof(Player), this.userAccessor.UserId);
}
var desiredTable = await this.tournamentTablesRepository
.AllAsNoTracking()
.Include(tt => tt.TeamTableResults)
.Include(ttr => ttr.Tournament)
.SingleOrDefaultAsync(tt => tt.Id == request.TableId, cancellationToken)
?? throw new NotFoundException(nameof(TournamentTable), request.TableId);
if (await this.CheckIfTournamentTableIsFull(request.TableId, cancellationToken))
{
throw new TournamentTableIsFullException();
}
if (await CommonCheckHelper.CheckIfPlayerHasAlreadyEnrolledATeam(this.userAccessor.UserId, desiredTable.Tournament.FormatId, teamsRepository))
{
throw new PlayerHasAlreadyEnrolledTeamException();
}
var desiredTeam = await this.teamsRepository
.AllAsNoTracking()
.Include(t => t.TeamTableResults)
.ThenInclude(ttr => ttr.TournamentTable)
.ThenInclude(tt => tt.Tournament)
.Include(t => t.PlayerTeams)
.SingleOrDefaultAsync(t => t.Id == request.TeamId, cancellationToken)
?? throw new NotFoundException(nameof(Team), request.TeamId);
if (!await this.CheckIfTeamToEnrollHasTheCorrectFormat(desiredTeam.Id, desiredTable.Tournament.FormatId, cancellationToken))
{
throw new TeamFormatDoesNotMatchTournamentFormatException();
}
if (!await this.CheckIfTeamToEnrollHasTheMinimumRequiredPlayers(desiredTeam.Id, desiredTable.Tournament.FormatId, cancellationToken))
{
throw new TeamDoesNotHaveEnoughPlayersException(desiredTeam.Name);
}
var tableResult = new TeamTableResult()
{
TeamId = request.TeamId, TournamentTableId = desiredTable.Id
};
desiredTable.TeamTableResults.Add(tableResult);
this.tournamentTablesRepository.Update(desiredTable);
return(await this.tournamentTablesRepository.SaveChangesAsync(cancellationToken));
}
public async Task <EnrollATeamCommand> Handle(EnrollATeamQuery request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
var currentUserId = this.userAccessor.UserId;
if (!await CommonCheckHelper.CheckIfPlayerExists(currentUserId, this.playersRepository))
{
throw new NotFoundException(nameof(Player), currentUserId);
}
if (await CommonCheckHelper.CheckIfPlayerIsVACBanned(currentUserId, this.playersRepository))
{
throw new PlayerIsVacBannedException();
}
var desiredTournament = await this.tournamentsRepository
.AllAsNoTracking()
.Include(t => t.Tables)
.ThenInclude(tt => tt.TeamTableResults)
.SingleOrDefaultAsync(t => t.Id == request.TournamentId, cancellationToken)
?? throw new NotFoundException(nameof(Tournament), currentUserId);
if (await CommonCheckHelper.CheckIfPlayerHasAlreadyEnrolledATeam(currentUserId, desiredTournament.FormatId, this.teamsRepository))
{
throw new PlayerHasAlreadyEnrolledTeamException();
}
var eligibleTeams = await this.teamsRepository
.AllAsNoTracking()
.Where(t => t.OwnerId == currentUserId && t.TournamentFormatId == desiredTournament.FormatId)
.ProjectTo <TeamsSelectItemLookupModel>(this.mapper.ConfigurationProvider)
.ToListAsync(cancellationToken);
if (eligibleTeams.Count == 0)
{
throw new PlayerHasNoEligibleTeamsToEnrollException();
}
var skillTables = this.mapper.Map <IList <TournamentTableSelectItemLookupModel> >(
desiredTournament.Tables.Where(t => t.TeamTableResults.Count < t.MaxNumberOfTeams));
if (skillTables.Count == 0)
{
throw new TournamentTablesAreFullException();
}
return(new EnrollATeamCommand
{
TournamentName = desiredTournament.Name,
TournamentId = desiredTournament.Id,
Teams = eligibleTeams,
Tables = skillTables
});
}
public async Task <int> Handle(CreateTeamCommand request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
var currentUserId = this.userAccessor.UserId;
if (!await CommonCheckHelper.CheckIfPlayerHasLinkedSteamAccount(currentUserId, this.playersRepository))
{
throw new PlayerDoesNotHaveALinkedSteamAccountException();
}
if (!await this.CheckIfTournamentFormatExists(request))
{
throw new NotFoundException(nameof(TournamentFormat), request.TournamentFormatId);
}
if (await CommonCheckHelper.CheckIfPlayerIsAlreadyInATeamWithTheSameFormat(currentUserId, request.TournamentFormatId, this.playerTeamsRepository))
{
throw new PlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException();
}
if (await this.CheckIfTeamWithTheSameNameExists(request))
{
throw new EntityAlreadyExistsException(nameof(Team), request.Name);
}
var team = this.mapper.Map <Team>(request);
team.OwnerId = currentUserId;
if (request.TeamImage != null)
{
team.ImageUrl = await this.UploadTeamImage(request);
}
team.PlayerTeams.Add(new PlayerTeam()
{
Team = team, PlayerId = currentUserId
});
await this.teamsRepository.AddAsync(team);
await this.teamsRepository.SaveChangesAsync(cancellationToken);
return(team.Id);
}
public async Task <PlayWeeksForTournamentTableViewModel> Handle(GetPlayWeeksForTournamentTableQuery request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
if (!await CommonCheckHelper.CheckIfTournamentTableExists(request.TournamentTableId, this.tournamentTablesRepository))
{
throw new NotFoundException(nameof(TournamentTable), request.TournamentTableId);
}
var weeksForTournamentTableLookups = await this.playWeeksRepository
.AllAsNoTracking()
.Where(pw => pw.TournamentTableId == request.TournamentTableId)
.OrderByDescending(pw => pw.StartDate)
.ProjectTo <PlayWeekLookupModel>(this.mapper.ConfigurationProvider)
.ToListAsync(cancellationToken);
var viewModel = new PlayWeeksForTournamentTableViewModel {
PlayWeeks = weeksForTournamentTableLookups
};
return(viewModel);
}
public async Task <TeamsForPlayerViewModel> Handle(GetTeamsForPlayerQuery request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
if (!await CommonCheckHelper.CheckIfPlayerExists(request.UserId, this.playersRepository))
{
throw new NotFoundException(nameof(Player), request.UserId);
}
var teams = await(request.WithDeleted
? this.playerTeamsRepository.AllAsNoTrackingWithDeleted()
: this.playerTeamsRepository.AllAsNoTracking())
.Include(x => x.Team)
.Where(x => x.PlayerId == request.UserId)
.OrderByDescending(x => x.CreatedOn)
.ProjectTo <TeamForPlayerLookupModel>(this.mapper.ConfigurationProvider)
.ToListAsync(cancellationToken);
var viewModel = new TeamsForPlayerViewModel {
PlayerTeams = teams
};
return(viewModel);
}
public async Task <int> Handle(InvitePlayerCommand request, CancellationToken cancellationToken)
{
request = request ?? throw new ArgumentNullException(nameof(request));
if (string.IsNullOrWhiteSpace(request.UserName))
{
throw new InvalidSearchQueryException();
}
var desiredPlayer = await this.playersRepository
.AllAsNoTracking()
.Include(p => p.PlayerTeams)
.ThenInclude(pt => pt.Team)
.Include(p => p.Claims)
.SingleOrDefaultAsync(p => p.UserName == request.UserName, cancellationToken)
?? throw new PlayerDoesNotExistException(request.UserName);
if (!await CommonCheckHelper.CheckIfPlayerHasLinkedSteamAccount(desiredPlayer.Id, this.playersRepository))
{
throw new PlayerDoesNotHaveALinkedSteamAccountException(desiredPlayer.UserName);
}
if (desiredPlayer.Claims.Any(c => c.ClaimType == IS_VAC_BANNED_CLAIM_TYPE))
{
throw new PlayerIsVacBannedException(desiredPlayer.UserName);
}
var desiredTeam = await this.teamsRepository
.AllAsNoTracking()
.Include(t => t.TournamentFormat)
.SingleOrDefaultAsync(t => t.Id == request.TeamId, cancellationToken)
?? throw new NotFoundException(nameof(Team), request.TeamId);
if (this.CheckIfUserIsPartOfATeamWithTheSameFormat(desiredPlayer, desiredTeam.TournamentFormatId))
{
throw new PlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException(request.UserName);
}
if (await CommonCheckHelper.CheckIfTeamIsFull(desiredTeam.Id, this.teamsRepository))
{
throw new TeamIsFullException(desiredTeam.Name);
}
if (await this.CheckIfUserAlreadyHasAnInviteForGivenTeam(request))
{
throw new PlayerAlreadyHasPendingInvite(request.UserName);
}
var invite = new TeamInvite
{
PlayerId = desiredPlayer.Id,
TeamId = desiredTeam.Id,
TeamName = desiredTeam.Name,
SenderUsername = this.userAccessor.Username
};
await this.teamInvitesRepository.AddAsync(invite);
var rowsAffected = await this.teamInvitesRepository.SaveChangesAsync(cancellationToken);
await this.mediator.Publish(new PlayerInvitedNotification
{
SenderName = invite.SenderUsername,
ReceiverId = desiredPlayer.Id,
TeamName = desiredTeam.Name
});
return(rowsAffected);
}
