public async Task <List <TeamPlayer> > SplitTeams(List <int> playerIds, int teamAId, int teamBId)
{
foreach (var playerId in playerIds)
{
await _playerService.CalculateAverageRankForPlayer(playerId);
}
var players = new List <Player>();
decimal sum = 0;
foreach (var playerId in playerIds)
{
var player = await _playerRepository.GetPlayerById(playerId);
players.Add(player);
if (player.AverageRank != null)
{
sum = sum + player.AverageRank.Value;
}
}
//Teams are ok
var teamsPlayers = CalculateEqualTeams(players, teamAId, teamBId);
await _matchRepository.CreateMatch(new Match()
{
TeamA = await _repository.GetTeamById(teamAId),
TeamB = await _repository.GetTeamById(teamBId)
});
return(await SaveTeamPlayers(teamsPlayers));
}
public Match CreateMatch(int stadiumId, DateTime dateTime, string header)
{
if (GetAvailableTimesForNewMatch(stadiumId, dateTime).Count < 1)
{
throw new InvalidOperationException(String.Format("Train {0} is occupied at {1}. Run can not be created", stadiumId, dateTime));
}
var stadium = _stadiumRepo.Get(stadiumId);
var match = new Match()
{
StadiumId = stadium.Id, DateTime = dateTime, Header = header, PlaceAtMatches = new List <PlaceAtMatch>()
};
foreach (var sector in stadium.Sectors)
{
foreach (var place in sector.Places)
{
var newPlaceAtMatch = new PlaceAtMatch()
{
Number = place.Number,
SectorNumber = sector.Number,
Match = match
};
match.PlaceAtMatches.Add(newPlaceAtMatch);
}
;
}
;
_matchRepo.CreateMatch(match);
return(match);
}
public List <Match> CreateMatches(List <Match> matches)
{
try
{
foreach (Match match in matches)
{
_matchVali.CheckIfMatchIsNull(match);
_matchVali.ValidateMatch(match);
_matchVali.ValidateMatchStartDate(match);
}
return(_matchRepo.CreateMatch(matches).ToList());
}catch (Exception ex)
{
throw ex;
}
}
public async Task <string> CreateMatch(Match match, IEnumerable <MatchTeam> teams)
{
var matchId = await _matchRepository.CreateMatch(match);
var allResults = new List <GuardianMatchResult>();
foreach (var team in teams)
{
team.Id = $"{ModelIDPrefixes.MatchTeam}_{Guid.NewGuid():N}";
team.MatchId = matchId;
foreach (var results in team.GuardianMatchResults)
{
results.Id = $"{ModelIDPrefixes.GuardianMatchResult}_{Guid.NewGuid():N}";
results.MatchId = matchId;
results.MatchTeamId = team.Id;
results.GuardianId = await _guardianRepository.GetGuardianId(results.GuardianName);
await _guardianRepository.UpdateGuardianStats(results.GuardianId, results.Kills, results.Deaths);
allResults.Add(results);
}
}
await _guardianEfficiencyRepository.UpdateGuardianMatchEfficiency(allResults);
await _matchTeamRepository.WriteMatchTeams(teams);
await _matchResultsRepository.SaveGuardianResults(allResults);
var winner = GetWinner(teams);
var losingTeams = teams.Where(team => team.Id != winner.Id);
await CalculateWinningElo(winner, losingTeams);
await CalculateLosingElos(winner, losingTeams);
return(matchId);
}
public async Task <ActionResult> CreateMatch([Bind(Prefix = "Match", Include = "Season")] Match postedMatch)
{
if (postedMatch is null)
{
throw new ArgumentNullException(nameof(postedMatch));
}
var model = new EditLeagueMatchViewModel(CurrentPage, Services.UserService)
{
Match = postedMatch
};
model.Match.MatchType = MatchType.LeagueMatch;
_editMatchHelper.ConfigureModelFromRequestData(model, Request.Unvalidated.Form, Request.Form, ModelState);
if (Request.RawUrl.StartsWith("/competitions/", StringComparison.OrdinalIgnoreCase))
{
model.Match.Season = model.Season = await _seasonDataSource.ReadSeasonByRoute(Request.RawUrl, true).ConfigureAwait(false);
}
else if (model.Match.Season != null && model.Match.Season.SeasonId.HasValue)
{
// Get the season, to support validation against season dates
model.Match.Season = await _seasonDataSource.ReadSeasonById(model.Match.Season.SeasonId.Value).ConfigureAwait(false);
}
_matchValidator.DateIsValidForSqlServer(() => model.MatchDate, ModelState, "MatchDate", "match");
_matchValidator.DateIsWithinTheSeason(() => model.MatchDate, model.Match.Season, ModelState, "MatchDate", "match");
_matchValidator.TeamsMustBeDifferent(model, ModelState);
model.IsAuthorized[AuthorizedAction.CreateMatch] = User.Identity.IsAuthenticated;
if (model.IsAuthorized[AuthorizedAction.CreateMatch] && ModelState.IsValid &&
(model.Team == null || (model.PossibleSeasons != null && model.PossibleSeasons.Any())) &&
(model.Season == null || model.Season.MatchTypes.Contains(MatchType.LeagueMatch)))
{
var currentMember = Members.GetCurrentMember();
var createdMatch = await _matchRepository.CreateMatch(model.Match, currentMember.Key, currentMember.Name).ConfigureAwait(false);
await _cacheClearer.ClearCacheFor(createdMatch).ConfigureAwait(false);
return(Redirect(createdMatch.MatchRoute));
}
if (Request.RawUrl.StartsWith("/teams/", StringComparison.OrdinalIgnoreCase))
{
model.Team = await _teamDataSource.ReadTeamByRoute(Request.RawUrl, true).ConfigureAwait(false);
var possibleSeasons = _createMatchSeasonSelector.SelectPossibleSeasons(model.Team.Seasons, model.Match.MatchType).ToList();
if (possibleSeasons.Count == 1)
{
model.Match.Season = possibleSeasons.First();
}
model.PossibleSeasons = _editMatchHelper.PossibleSeasonsAsListItems(possibleSeasons);
await _editMatchHelper.ConfigureModelPossibleTeams(model, possibleSeasons).ConfigureAwait(false);
model.Metadata.PageTitle = $"Add a {MatchType.LeagueMatch.Humanize(LetterCasing.LowerCase)} for {model.Team.TeamName}";
}
else
{
model.PossibleSeasons = _editMatchHelper.PossibleSeasonsAsListItems(new[] { model.Match.Season });
model.PossibleHomeTeams = _editMatchHelper.PossibleTeamsAsListItems(model.Season?.Teams);
model.PossibleAwayTeams = _editMatchHelper.PossibleTeamsAsListItems(model.Season?.Teams);
model.Metadata.PageTitle = $"Add a {MatchType.LeagueMatch.Humanize(LetterCasing.LowerCase)} in the {model.Season.SeasonFullName()}";
}
model.Breadcrumbs.Add(new Breadcrumb {
Name = Constants.Pages.Matches, Url = new Uri(Constants.Pages.MatchesUrl, UriKind.Relative)
});
return(View("CreateLeagueMatch", model));
}
public Match CreateMatch(Match thisMatch)
{
return(_matchRepository.CreateMatch(thisMatch));
}
public void AddMatch(MatchDto Input)
{
_repository.CreateMatch(Input);
}
public async Task <Match> CreateMatch(Match match)
{
return(await _repository.CreateMatch(match));
}
