public async Task <CampeonatoEntity> GerarCampeonato()
        {
            List <TimeEntity> times = (List <TimeEntity>) await _timeService.GetAll();

            var campeonato = new CampeonatoEntity();

            var partidas = await _partidaService.GerarPartidas();

            var pontuacoesCampeonato         = _pontuacaoCampeonatoService.CalcularPontuacaoCampeonato(partidas, campeonato, times);
            var pontuacoesCampeonatoOrdenado = pontuacoesCampeonato.OrderByDescending(x => x.Pontuacao);

            campeonato.Partidas = partidas;
            campeonato.Campeao  = pontuacoesCampeonatoOrdenado.ElementAt(0).Time;
            campeonato.Vice     = pontuacoesCampeonatoOrdenado.ElementAt(1).Time;
            campeonato.Terceiro = pontuacoesCampeonatoOrdenado.ElementAt(2).Time;

            var campeonatoCompleto = await _reposotory.InsertAsync(campeonato);

            //Salva pontuacoesCampeonato no banco
            foreach (var item in pontuacoesCampeonato)
            {
                item.Campeonato = campeonatoCompleto;
                await _pontuacaoCampeonatoService.Post(item);
            }

            //Salva partidas no banco
            partidas.ForEach(partida => _partidaService.Post(partida));

            return(campeonatoCompleto);
        }
예제 #2
0
        public async Task <CampeonatoEntity> Put(CampeonatoEntity user)
        {
            var result = await _campeonatoService.Put(user);

            await _campeonatoService.Commit();

            return(result);
        }
예제 #3
0
        public async Task <CampeonatoEntity> Post(CampeonatoEntity user)
        {
            try
            {
                var result = await _campeonatoService.Post(user);

                await _campeonatoService.Commit();

                return(await _campeonatoService.GetByCod(result.codigoCampeonato));
            }
            catch (Exception)
            {
                _campeonatoService.Dispose();
                throw;
            }
        }
        //TODO ver se não ter problema esse método não ser assíncrono e os outros serem
        public List <PontuacaoCampeonatoEntity> CalcularPontuacaoCampeonato(List <PartidaEntity> partidas, CampeonatoEntity campeonato, List <TimeEntity> times)
        {
            List <PontuacaoCampeonatoEntity> pontuacoesCampeonato = new List <PontuacaoCampeonatoEntity>();

            //Gera lista de PontuacaoCampeonato com times
            foreach (var time in times)
            {
                var PontuacaoCampeonato = new PontuacaoCampeonatoEntity();
                PontuacaoCampeonato.Time = time;
                pontuacoesCampeonato.Add(PontuacaoCampeonato);
            }

            //Calcula a pontuação de cada time
            foreach (var partida in partidas)
            {
                if (partida.Gols1 > partida.Gols2)
                {
                    var teste = pontuacoesCampeonato.Find(x => x.Time == partida.Time1);

                    teste.Pontuacao += 3;
                }
                else if (partida.Gols1 < partida.Gols2)
                {
                    var teste = pontuacoesCampeonato.Find(x => x.Time == partida.Time2);

                    teste.Pontuacao += 3;
                }
                else
                {
                    var teste = pontuacoesCampeonato.Find(x => x.Time == partida.Time2);
                    teste.Pontuacao += 1;

                    teste            = pontuacoesCampeonato.Find(x => x.Time == partida.Time1);
                    teste.Pontuacao += 1;
                }
            }
            return(pontuacoesCampeonato);
        }
예제 #5
0
        public async Task <CampeonatoEntity> Post(CampeonatoEntity campeonato)
        {
            try
            {
                var pontuacaoCampeonatoList = new List <PontuacaoCampeonatoEntity>();
                var result = await _repository.InsertAsync(campeonato);

                var times = _timeservice.GetAll();
                foreach (var time in times.Result)
                {
                    PontuacaoCampeonatoEntity pontuacao = new PontuacaoCampeonatoEntity
                    {
                        time = time, codigoCampeonato = result.codigoCampeonato
                    };
                    pontuacaoCampeonatoList.Add(await _pontuacaoCampeonatoRepository.InsertAsync(pontuacao));
                }

                var random = new Random();
                List <PartidaEntity> partidas = new List <PartidaEntity>();
                foreach (var time in times.Result)
                {
                    foreach (var time2 in times.Result)
                    {
                        if (time == time2)
                        {
                            continue;
                        }
                        if (partidas.Any(x =>
                                         (x.timeA == time && x.timeB == time2) || (x.timeA == time2 && x.timeB == time)))
                        {
                            continue;
                        }
                        PartidaEntity partida = new PartidaEntity
                        {
                            timeA = time, timeB = time2, golsA = random.Next(0, 7), golsB = random.Next(0, 7)
                        };
                        DateTime DataPermitida = DataCampeonato();
                        partida.data             = DataPermitida;
                        partida.codigoCampeonato = result.codigoCampeonato;
                        var resultPartida = await _partidaService.Post(partida);

                        if (resultPartida != null)
                        {
                            partidas.Add(partida);
                        }
                    }
                }

                var pontuacaoList = await adicionarPartidaPontuacao(partidas, pontuacaoCampeonatoList);

                campeonato.partidas = partidas;
                result.campeao      = pontuacaoList.OrderByDescending(x => x.pontuacaoTime).Select(x => x.time).FirstOrDefault();
                result.vici         = pontuacaoList.OrderByDescending(x => x.pontuacaoTime).Select(x => x.time).ElementAt(2);
                result.terceiro     = pontuacaoList.OrderByDescending(x => x.pontuacaoTime).Select(x => x.time).ElementAt(3);
                result.dataFinal    = partidas.OrderBy(x => x.data).LastOrDefault()?.data;
                await _repository.UpdateAsync(result);

                return(result);
            }
            catch (Exception)
            {
                _repository.Dispose();
            }
            return(null);
        }
예제 #6
0
 public async Task <CampeonatoEntity> Put(CampeonatoEntity user)
 {
     return(await _repository.UpdateAsync(user));
 }
 public async Task <CampeonatoEntity> Put(CampeonatoEntity campeonato)
 {
     return(await _reposotory.UpdateAsync(campeonato));
 }
 public async Task <CampeonatoEntity> Post(CampeonatoEntity campeonato)
 {
     return(await _reposotory.InsertAsync(campeonato));
 }