public ActionResult Calcular([FromBody] ModelRequest <CalculoTimeModel> timeCommand)
        {
            CalculoTimeCommand timeCalculo = new CalculoTimeCommand();

            if (timeCommand.Value.TipoCalculo.Equals("media", StringComparison.InvariantCultureIgnoreCase))
            {
                timeCalculo.TipoCalculo = TipoCalculo.MediaAnual;
                timeCalculo.AnoInicio   = timeCommand.Value.AnoInicio;
                timeCalculo.AnoFim      = timeCommand.Value.AnoFim;
            }
            else
            {
                timeCalculo.TipoCalculo = TipoCalculo.Media3Anos;
                timeCalculo.AnoInicio   = timeCommand.Value.AnoBase - 1;
                timeCalculo.AnoFim      = timeCommand.Value.AnoBase + 1;
            }

            timeCalculo.Categoria   = EnumUtil.ParseEnum <TipoCategoria>(timeCommand.Value.Categoria.Replace(" ", ""));
            timeCalculo.Criterio    = timeCommand.Value.Criterio.Replace(" ", "") == "Por36minutos" ? TipoCriterio.EstatisticaPer36Minutes : TipoCriterio.EstatisticaPer36Oponente;
            timeCalculo.Conferencia = EnumUtil.ParseEnum <TipoConferencia>(timeCommand.Value.Conferencia);
            var times = _calculoTimeAppService.CalcularTime(timeCalculo).ToList();

            ViewBag.dataSource = times;

            var datasource = times;

            return(Json(datasource));
        }
        private void MontarRetorno(CalculoTimeCommand calculoTime, List <CalculoTimeResponse> timesResult, List <TemporadaTime> temporadaTimes, List <TemporadaBaseCalculo> temporadaCalculo, double?valorEstatistica)
        {
            foreach (var temporadas in temporadaTimes)
            {
                foreach (var item in temporadas.Times)
                {
                    var timeTemp = _timeService.GetAll().FirstOrDefault(x => x.Id == item.Time_ID);
                    var tt       = new CalculoTimeResponse();
                    tt.AnoTemporada     = temporadas.Ano;
                    tt.Nome             = timeTemp.Nome;
                    tt.Conferencia      = (TipoConferencia)System.Enum.Parse(typeof(TipoConferencia), timeTemp.Conferencia);
                    tt.ParametroCalculo = valorEstatistica == null?temporadaCalculo.FirstOrDefault(x => x.Ano == temporadas.Ano).ValorEstatistica : valorEstatistica.Value;

                    if (calculoTime.Criterio == TipoCriterio.EstatisticaPer36Minutes)
                    {
                        tt.ValorEstatistica = ObterValorEstatistica(calculoTime.Categoria.Value, item.EstatisticaTime);
                    }
                    else
                    {
                        tt.ValorEstatistica = ObterValorEstatistica(calculoTime.Categoria.Value, item.EstatisticaOponenteTime);
                    }

                    timesResult.Add(tt);
                }
            }
        }
Esempio n. 3
0
 public IList <CalculoTimeResponse> CalcularTime(CalculoTimeCommand calculoTime)
 {
     return(_calculoTimeService.CalcularTime(calculoTime));
 }
 public IList <CalculoTimeResponse> CalcularTime(CalculoTimeCommand calculoTime)
 {
     throw new NotImplementedException();
 }
        public IList <CalculoTimeResponse> CalcularTime(CalculoTimeCommand calculoTime)
        {
            var timesResult = new List <CalculoTimeResponse>();

            //Ano
            var temporadaTimes = _temporadaTimeService.GetAll().Where(x => x.Ano >= calculoTime.AnoInicio && x.Ano <= calculoTime.AnoFim).ToList();

            //Conferencia
            if (calculoTime.Conferencia != TipoConferencia.Ambas)
            {
                temporadaTimes = temporadaTimes.Select(x => new TemporadaTime
                {
                    Ano   = x.Ano,
                    Id    = x.Id,
                    Times = x.Times.Where(y => y.Time_Conferencia == calculoTime.Conferencia.ToString()).ToList()
                }).ToList();
            }

            //Media Anual
            if (calculoTime.TipoCalculo == TipoCalculo.MediaAnual)
            {
                //Criterio e Categoria
                var temporadaCalculo = new List <TemporadaBaseCalculo>();
                if (calculoTime.Criterio == TipoCriterio.EstatisticaPer36Minutes)
                {
                    temporadaCalculo = ObterEstatisticaTime(calculoTime.Categoria.Value, temporadaTimes).ToList();
                }
                else if (calculoTime.Criterio == TipoCriterio.EstatisticaPer36Oponente)
                {
                    temporadaCalculo = ObterEstatisticaOponenteTime(calculoTime.Categoria.Value, temporadaTimes).ToList();
                }

                //Retorno
                MontarRetorno(calculoTime, timesResult, temporadaTimes, temporadaCalculo, null);
            }
            //Media 3 ANOS
            else if (calculoTime.TipoCalculo == TipoCalculo.Media3Anos)
            {
                if (calculoTime.AnoFim - calculoTime.AnoInicio >= MEDIA3ANOS)
                {
                    throw new Exception("Período informado não possui um intervalo de 3 anos");
                }

                //Criterio e Categoria
                double valorEstatistica = 0;
                if (calculoTime.Criterio == TipoCriterio.EstatisticaPer36Minutes)
                {
                    valorEstatistica = ObterEstatisticaTime3Anos(calculoTime, temporadaTimes);
                }
                else if (calculoTime.Criterio == TipoCriterio.EstatisticaPer36Oponente)
                {
                    valorEstatistica = ObterEstatisticaOponenteTime3Anos(calculoTime, temporadaTimes);
                }

                //Retorno
                MontarRetorno(calculoTime, timesResult, temporadaTimes, null, valorEstatistica);
            }

            var res = timesResult.OrderByDescending(x => x.IndiceCalulo).ToList();

            return(res);
        }
        private double ObterEstatisticaOponenteTime3Anos(CalculoTimeCommand calculoTime, IList <TemporadaTime> temporadaTime)
        {
            var    temporadaTimeCalculo = new List <TemporadaBaseCalculo>();
            double valorEstatistica     = 0;

            switch (calculoTime.Categoria)
            {
            case TipoCategoria.Arremessos2Pontos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos2Pontos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Arremessos2PontosTentados:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos2PontosTentados).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Arremessos3Pontos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos3Pontos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Arremessos3PontosTentados:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Arremessos3PontosTentados).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.ArremessosConvertidos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.ArremessosConvertidos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.ArremessosTentados:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.ArremessosTentados).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Assistencias:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Assistencias).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.DesperdiciosBola:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.DesperdiciosBola).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Faltas:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Faltas).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.LancesLivres:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.LancesLivres).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.LancesLivresTentados:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.LancesLivresTentados).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Pontos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Pontos).Average(), 2)
                    }).ToList();

                break;
            }

            case TipoCategoria.Porcentagem2Pontos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Porcentagem2Pontos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Porcentagem3Pontos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Porcentagem3Pontos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.PorcentagemArremessos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.PorcentagemArremessos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.PorcentagemLancesLivres:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.PorcentagemLancesLivres).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.RebotesDefensivos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.RebotesDefensivos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.RebotesOfensivos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.RebotesOfensivos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.RoubosBola:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.RoubosBola).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.Tocos:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.Tocos).Average(), 2)
                    }).ToList();
                break;
            }

            case TipoCategoria.TotalRebotes:
            {
                temporadaTimeCalculo = temporadaTime.Select(x => new TemporadaBaseCalculo
                    {
                        ValorEstatistica = Math.Round(x.Times.Select(y => y.EstatisticaOponenteTime.TotalRebotes).Average(), 2)
                    }).ToList();
                break;
            }

            default:
                return(0);
            }

            valorEstatistica = Math.Round(temporadaTimeCalculo.Select(x => x.ValorEstatistica).Average());

            return(valorEstatistica);
        }