protected string GetType(Tournament tournoi) { if (tournoi is EliminationTournament) return "Elimination"; if (tournoi is PoolEliminationTournament) return "PoolElimination"; if (tournoi is PoolTournament) return "Pool"; if (tournoi is RoundTournament) return "Round"; throw new ApplicationException("Type de tournoi non reconnu"); }
public async Task<Tournament> Update(Tournament tournament, string userMatricule) { //récupération du tournoi existant Tournament currentTournament = await Get(tournament.Id); if (currentTournament == null) { throw new NullReferenceException(string.Format("le tournoi avec l'id {0} est introuvable", tournament.Id)); } if (currentTournament.CreatorId != userMatricule) throw new InvalidOperationException("Seul le créateur du tournoi peut le modifier"); //suppression des équipes currentTournament.Teams.ToList().ForEach(t => _teamStore.SetState(t, EntityState.Deleted)); currentTournament.Teams.Clear(); //recréation des équipes List<string> matricules = tournament.Teams.SelectMany(p => p.Players).Where(p => p != null).Select(p => p.Matricule).ToList(); var players = await _playerStore.GetFromMatricules(matricules); foreach (Team team in tournament.Teams.Where(team => team != null && team.Players != null)) { team.Id = 0; team.Players = team.Players.Where(p => p != null).Select(m => players.FirstOrDefault(j => m.Matricule == j.Matricule)).Where(p => p != null).ToList(); currentTournament.Teams.Add(team); } await _teamStore.Add(tournament.Teams); //maj du match currentTournament.Date = tournament.Date; currentTournament.Name = tournament.Name; currentTournament.Private = tournament.Private; currentTournament.Ranked = tournament.Ranked; currentTournament.SportKey = tournament.SportKey; var tournamentSystem = _tournamentSystemFactory.Get(currentTournament); tournamentSystem.Create(); await _tournamentStore.SaveChangesAsync(); return tournament; }
public async Task CreateTournamentFinaleTest() { var matchBP = new TournamentBP(_playerStoreMock.Object, _teamStoreMock.Object,_sportStoreMock.Object, _tournamentStoreMock.Object, _tournamentSystemFactoryMock.Object); var tournament = new Tournament { CreatorId = "test", Id = 1, Teams = CreateTeams(4) }; _tournamentStoreMock.Setup(t => t.Get(1)).ReturnsAsync(tournament); _tournamentSystemFactoryMock.Setup(m => m.Get(tournament)).Returns(_tournamentSystemMock.Object); _tournamentSystemMock.Setup(m => m.Create()); _tournamentStoreMock.Setup(m => m.SaveChangesAsync()).Returns(() => Task.FromResult(default(Task))); await matchBP.CreateMatchs(new Tournament { Id = 1 }, "test"); _tournamentSystemMock.Verify(m=>m.Create(),Times.Once()); Assert.IsNotNull(tournament.Qualifications); }
public async Task<Tournament> CreateMatchs(Tournament tournament, string userMatricule) { //récupération du match existant Tournament currentTournament = await Get(tournament.Id); if (currentTournament == null) { throw new NullReferenceException(string.Format("le tournoi avec l'id {0} est introuvable", tournament.Id)); } if (currentTournament.State != StateEnum.Opened) throw new InvalidOperationException("Le tournoi est déjà en cours ou clos"); if (currentTournament.CreatorId != userMatricule) throw new InvalidOperationException("Seul le créateur du tournoi peut le modifier"); var tournamentSystem = _tournamentSystemFactory.Get(currentTournament); tournamentSystem.Tournament = currentTournament; tournamentSystem.Create(); await _tournamentStore.SaveChangesAsync(); return currentTournament; }
public async Task<Tournament> Leave(Tournament tournament, string playerMatricule, string userMatricule) { var currentMatch = await _tournamentStore.Get(tournament.Id); if (currentMatch == null) throw new InstanceNotFoundException("Le tournoi est introuvable"); if (currentMatch.State == StateEnum.Draw || currentMatch.State == StateEnum.Won) throw new InvalidOperationException("Le tournoi est déjà clos"); if (playerMatricule != userMatricule && currentMatch.CreatorId != userMatricule) throw new InvalidOperationException("Seul le créateur du tournoi peut modifier sa composition"); var player = await _playerStore.GetFromMatricule(playerMatricule); if (player == null) throw new InvalidOperationException("Le joueur est introuvable"); var team = currentMatch.Teams.SingleOrDefault(t => t.Players.Select(p => p.Matricule.ToLowerInvariant()).Contains(playerMatricule.ToLowerInvariant())); if (team == null) throw new InvalidOperationException("Le joueur ne fait parti d'aucune équipe"); team.Players.Remove(player); await _playerStore.SaveChangesAsync(); return await Task.FromResult(currentMatch); }
public async Task<Tournament> Join(Tournament tournament, int teamId, string playerMatricule, string userMatricule) { var currentTournament = await _tournamentStore.Get(tournament.Id); if (currentTournament == null) throw new InstanceNotFoundException("Le tournoi est introuvable"); if (currentTournament.State == StateEnum.Draw || currentTournament.State == StateEnum.Won) throw new InvalidOperationException("Le tournoi est déjà clos"); if (playerMatricule != userMatricule && currentTournament.CreatorId != userMatricule) throw new InvalidOperationException("Seul le créateur du tournoi peut modifier sa composition"); var player = await _playerStore.GetFromMatricule(playerMatricule); if (player == null) throw new InvalidOperationException("Le joueur est introuvable"); if (currentTournament.Teams.SelectMany(t => t.Players).Select(p => p.Matricule.ToLowerInvariant()).Contains(playerMatricule.ToLowerInvariant())) throw new InvalidOperationException("Le joueur fait déjà parti d'une équipe"); var team = currentTournament.Teams.SingleOrDefault(t => t.Id == teamId); if (team == null) throw new InvalidOperationException("L'équipe n'est pas liée au match"); var currentSport = await _sportStore.Get(currentTournament.SportKey); if (team.Players.Count >= currentSport.MaxPlayers) throw new InvalidOperationException("L'équipe est déjà complète"); team.Players.Add(player); await _playerStore.SaveChangesAsync(); return await Task.FromResult(currentTournament); }
private void RandomizeTeams(Tournament tournament) { //récupération des joueurs var rnd = new Random(); List<Player> players = tournament.Teams.SelectMany(p => p.Players).Where(p => p != null).OrderBy(item => rnd.Next()).ToList(); tournament.Teams.ForEach(t => t.Players.Clear()); while (players.Count > 0) { foreach (var team in tournament.Teams) { if (players.Count <= 0) break; var player = players.First(); players.RemoveAt(0); team.Players.Add(player); } } //suppression des équipes vides tournament.Teams.Where(t => t.Players.Count == 0).ToList().ForEach(t => _teamStore.SetState(t, EntityState.Deleted)); tournament.Teams = tournament.Teams.Where(t => t.Players.Count > 0).ToList(); }
public async Task<Tournament> Add(Tournament tournament, string userMatricule) { tournament.CreatorId = userMatricule; foreach (Team team in tournament.Teams.Where(team => team != null && team.Players != null)) { List<string> players = team.Players.Where(p => p != null).Select(p => p.Matricule).ToList(); team.Players = await _playerStore.GetFromMatricules(players); } tournament.Sport = await _sportStore.Get(tournament.SportKey); var tournamentSystem = _tournamentSystemFactory.Get(tournament); tournamentSystem.Tournament = tournament; tournamentSystem.Create(); await _teamStore.Add(tournament.Teams); await _tournamentStore.Add(tournament); await _tournamentStore.SaveChangesAsync(); return tournament; }
public async Task<IHttpActionResult> Join(Tournament tournament, int teamId ) { return Ok(TournamentModel.From(await _tournamentBP.Join(tournament, teamId, _userMatricule, _userMatricule))); }
public async Task<IHttpActionResult> Post(Tournament tournament) { var newMatch = await _tournamentBP.Add(tournament, _userMatricule); return Ok(TournamentModel.From(newMatch)); }
public async Task<IHttpActionResult> Put(int id, Tournament tournament) { var newMatch = await _tournamentBP.Update(tournament, _userMatricule); return Ok(TournamentModel.From(newMatch)); }
public async Task<Tournament> SetState(Tournament tournament, EntityState entityState) { _matchContext.Entry(tournament).State = entityState; return await Task.FromResult(tournament); }
public async Task<Tournament> Add(Tournament tournament) { _matchContext.Tournaments.Add(tournament); return await Task.FromResult(tournament); }
private static void From(TournamentModel tournamentModel, Tournament tournament) { if (tournament == null) return; tournamentModel.Type = tournament.Type; tournamentModel.CreatorId = tournament.CreatorId; tournamentModel.Creator = PlayerModel.From(tournament.Creator); tournamentModel.Date = tournament.Date; tournamentModel.Id = tournament.Id; tournamentModel.Name = tournament.Name; tournamentModel.Private = tournament.Private; tournamentModel.Ranked = tournament.Ranked; tournamentModel.Randomize = tournament.Randomize; tournamentModel.SportKey = tournament.SportKey; tournamentModel.WinnerId = tournament.WinnerId; tournamentModel.Teams = tournament.Teams.Select(TeamModel.From).ToList(); tournamentModel.State = tournament.State; tournamentModel.Qualifications = tournament.Qualifications.Select(QualificationModel.From).ToList(); }
public static TournamentModel From(Tournament tournament) { if (tournament == null) return null; if (tournament is EliminationTournament) return From((EliminationTournament)tournament); if (tournament is PoolTournament) return From((PoolTournament)tournament); if (tournament is PoolEliminationTournament) return From((PoolEliminationTournament)tournament); if (tournament is RoundTournament) return From((RoundTournament)tournament); return null; }
public async Task<IHttpActionResult> Leave(Tournament tournament) { return Ok(TournamentModel.From(await _tournamentBP.Leave(tournament, _userMatricule, _userMatricule))); }
public async Task<Tournament> Start(Tournament tournament, string userMatricule) { //récupération du tournoi existant Tournament currentTournament = await Get(tournament.Id); if (currentTournament == null) { throw new NullReferenceException(string.Format("le tournoi avec l'id {0} est introuvable", tournament.Id)); } if (currentTournament.State != StateEnum.Opened) throw new InvalidOperationException("Le tournoi est déjà en cours ou clos"); if (currentTournament.CreatorId != userMatricule) throw new InvalidOperationException("Seul le créateur du tournoi peut le démarrer"); if (currentTournament.Randomize) RandomizeTeams(tournament); currentTournament.State = StateEnum.InProgress; ///TODO: création des pools et des qualifs var tournamentSystem = _tournamentSystemFactory.Get(currentTournament); tournamentSystem.Create(); await _tournamentStore.SaveChangesAsync(); return currentTournament; }
public ITournamentSystem Get(Tournament tournament) { var type = tournament.GetType(); return (ITournamentSystem)_container.Resolve(typeof(ITournamentSystem<>).MakeGenericType(type)); }