public async Task <IActionResult> EditLimite([FromBody] LimiteViewModel limite)
        {
            int limiteId = 0;

            try
            {
                limiteId = await _gerenciadorDeRequisicoesDeLimite.AtualizaLimiteAsync(limite);
            }
            catch (UserException ex)
            {
                EncapsuladorDeResposta <object> encapsuledResponse = new EncapsuladorDeResposta <object>(0);
                encapsuledResponse.Success          = false;
                encapsuledResponse.ExceptionMessage = ex.Message;
                return(Ok(encapsuledResponse));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }

            EncapsuladorDeResposta <int> enc = new EncapsuladorDeResposta <int>(limiteId);

            enc.Success = true;
            return(Ok(enc));
        }
        public async Task <int> AtualizaLimiteAsync(LimiteViewModel limiteVM)
        {
            ParametrosDeLimites limite = new ParametrosDeLimites(limiteVM);

            try
            {
                await _repositorioDeLimites.UpdateAsync(limite);
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return(limite.Id);
        }
        public async Task <IActionResult> NovoLimite()
        {
            LimiteViewModel limite = new LimiteViewModel();

            try
            {
                var DropDownContratos = await _gerenciadorDeRequisicoesDeContrato.RequisicaoListaContratosAsync();

                //limite.DropDownContratos = DropDownContratos.ToList();
                //var DropDownRegras = await _gerenciadorDeRequisicoesDeRegra.ListaRegrasAsync();
                //limite.DropDownRegras = DropDownRegras.ToList();
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }

            return(Ok(limite));
        }
        public async Task <IActionResult> NovoLimite([FromBody] LimiteViewModel limite)
        {
            try
            {
                object id = await _gerenciadorDeRequisicoesDeLimite.SalvaLimiteAsync(limite);

                EncapsuladorDeResposta <object> encapsuledResponse = new EncapsuladorDeResposta <object>(id);
                encapsuledResponse.Success = true;
                return(Ok(encapsuledResponse));
            }
            catch (UserException ex)
            {
                EncapsuladorDeResposta <object> encapsuledResponse = new EncapsuladorDeResposta <object>(0);
                encapsuledResponse.Success          = false;
                encapsuledResponse.ExceptionMessage = ex.Message;
                return(Ok(encapsuledResponse));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex));
            }
        }
        public async Task <object> SalvaLimiteAsync(LimiteViewModel limiteVM)
        {
            ParametrosDeLimites limite = new ParametrosDeLimites(limiteVM);

            return(await _repositorioDeLimites.InserirLimite(limite));
        }