public static List <Parcela> CalcularParcelas(decimal saldoDevedor, decimal taxaDeJuros, int prazo)
{
var parcelas = new List <Parcela>();
var saldoDevedorAtual = saldoDevedor;
var amortizacaoAtravesDoPrazo = saldoDevedor / prazo;
parcelas.Add(new Parcela(juros: 0, amortizacao: 0, saldoDevedor: saldoDevedor));
for (var numeroDaParcela = 0; numeroDaParcela < prazo; numeroDaParcela++)
{
var juros = JurosCompostos.CalcularJuros(saldoDevedorAtual, taxaDeJuros, prazo: 1);
saldoDevedorAtual -= amortizacaoAtravesDoPrazo;
var temQueCompensarDizimaPeriodica = numeroDaParcela == prazo - 1 && saldoDevedorAtual != 0;
if (temQueCompensarDizimaPeriodica)
{
amortizacaoAtravesDoPrazo += 0.01m;
}
parcelas.Add(new Parcela(juros.Arredondado(2), amortizacaoAtravesDoPrazo.Arredondado(2), saldoDevedorAtual.Arredondado(2)));
}
return(parcelas);
}
public IActionResult Post(JurosCompostos jurosCompostos)
{
CalculaJurosExecutor calcula = new CalculaJurosExecutor();
var valor = calcula.CalcularJuros(jurosCompostos);
return(Ok(valor));
}
public void AoCompararComOutroObjeto_DeveRetornarOValorEsperadoDeAcordoComOsValores(
JurosCompostos jurosCompostos, bool resultadoEsperado)
{
var resultado = _juros.Equals(jurosCompostos);
Assert.Equal(resultadoEsperado, resultado);
}
public decimal CalcularTruncandoEmDuasCasasDecimais(decimal valorInicial, int meses)
{
decimal taxaJuros;
try
{
taxaJuros = _taxaJurosServico.ObterTaxaJuros();
}
catch (Exception exception)
{
Notificar(string.Format("Não foi possível obter uma taxa de juros: {0}", exception.Message));
return(0);
}
JurosCompostos jurosCompostos = new JurosCompostos {
ValorInicial = valorInicial, TaxaJuros = taxaJuros, Meses = meses
};
if (!Validar(new ValidacaoJurosCompostos(), jurosCompostos))
{
return(0);
}
decimal valorCalculado = jurosCompostos.Calcular();
decimal valorTruncado = _truncarValoresServico.TruncarValor(valorCalculado, 2);
return(valorTruncado);
}
public void DeveCalcularJurosCompostosTruncadoSemArrendondamentoEmDuasCasasDecimais()
{
var jurosCompostos = new JurosCompostos(valorInicial: 100, taxaDeJuros: 0.01, tempoEmMeses: 8);
var valorEsperadoDeJuros = 108.28;
Assert.AreEqual(valorEsperadoDeJuros, jurosCompostos.calcular());
}
public void AoCriarUmObjeto_ComMesesMenorQueZero_DeveSinalizarQueOObjetoEInvalido(double valorInicialEsperado,
double taxaEsperada)
{
var juros = new JurosCompostos(valorInicialEsperado, taxaEsperada, -1);
Assert.False(juros.Valid);
}
public virtual async Task <JurosCompostos> Calcular(decimal valorInicial, int tempo)
{
var retorno = new JurosCompostos();
try
{
retorno.Mensagem = this.ValidaDadosEntrada(valorInicial, tempo);
if (!string.IsNullOrEmpty(retorno.Mensagem))
{
return(retorno);
}
var taxaJuros = await this.Repositorio.GetTaxa();
if (!taxaJuros.Sucesso)
{
retorno.Mensagem = taxaJuros.Mensagem;
return(retorno);
}
retorno = this.DefinirValoresParaCalculo(valorInicial, tempo, taxaJuros.Valor);
}
catch (Exception ex)
{
retorno.Mensagem = ex.Message;
}
return(retorno);
}
public void DeveLancarExcecaoParaTempoEmMesesMenorQueZero()
{
var jurosCompostos = new JurosCompostos(valorInicial: 20, taxaDeJuros: 0.5, tempoEmMeses: -1);
var exception = Assert.Throws <ApplicationException>(() => jurosCompostos.calcular());
Assert.That(exception.Message, Is.EqualTo("Tempo em meses deve ser maior igual a zero."));
}
public void DeveCalcularJurosCompostosIgualACentoECincoReaisEDezCentavos()
{
var jurosCompostos = new JurosCompostos(valorInicial: 100, taxaDeJuros: 0.01, tempoEmMeses: 5);
var valorEsperadoDeJuros = 105.1;
Assert.AreEqual(valorEsperadoDeJuros, jurosCompostos.calcular());
}
public void AoInformarMesesIgualAZero_DeveRetornarOValorINicial(JurosCompostos juros)
{
var retorno = _servico.ApurarMontante(juros);
var montanteEsperado = juros.ValorInicial;
Assert.Equal(montanteEsperado, retorno);
}
public void DeveCalcularJurosCompostosIgualAValorInicialParaTempoEmMesesIgualAZero()
{
var valorInicial = 100;
var jurosCompostos = new JurosCompostos(valorInicial: valorInicial, taxaDeJuros: 1, tempoEmMeses: 0);
Assert.AreEqual(valorInicial, jurosCompostos.calcular());
}
public async Task <JurosCompostos> RetornarTaxaJuros()
{
var taxajuros = await ConsultaJuros.PegarTaxaJuros();
var juroComposto = new JurosCompostos(ValorInicial, Meses, taxajuros);
return(juroComposto);
}
public void Setup()
{
_validacaoJurosCompostos = new ValidacaoJurosCompostos();
_jurosCompostos = new JurosCompostos {
ValorInicial = 100, TaxaJuros = 0.01M, Meses = 5
};
}
public void Deve_Validar_Se_ValorInicial_Positivo()
{
var valorInicial = 100;
var tempo = 5;
var jurosCompostos = new JurosCompostos(valorInicial, tempo);
Assert.True(jurosCompostos.Validar());
}
public void Nao_Deve_Validar_Se_ValorInicial_Zero()
{
var valorInicial = 0;
var tempo = 5;
var jurosCompostos = new JurosCompostos(valorInicial, tempo);
Assert.False(jurosCompostos.Validar());
}
public void Deve_Calcular_Com_Tempo_Negativo()
{
var valorInicial = 100;
var tempo = -6;
var jurosCompostos = new JurosCompostos(valorInicial, tempo);
Assert.Throws <InvalidOperationException>(() => new JurosCompostos(valorInicial, tempo).ValorFinal);
}
public void Deve_Calcular_ValorFinal_Errado()
{
var valorInicial = 100;
var tempo = 6;
var jurosCompostos = new JurosCompostos(valorInicial, tempo);
Assert.NotEqual(105.10M, jurosCompostos.ValorFinal);
}
public void Nao_Deve_Validar_Se_Tempo_Negativo()
{
var valorInicial = 100;
var tempo = -5;
var jurosCompostos = new JurosCompostos(valorInicial, tempo);
Assert.False(jurosCompostos.Validar());
}
public void Deve_Calcular_ValorInicial_Se_Tempo_Zero()
{
var valorInicial = 100;
var tempo = 0;
var jurosCompostos = new JurosCompostos(valorInicial, tempo);
Assert.Equal(jurosCompostos.ValorFinal, valorInicial);
}
public double CalcularJuroComposto(JurosCompostos jurosCompostos)
{
var juros = jurosCompostos.ValorInicial * Math.Pow((1 + jurosCompostos.TaxaJuros), jurosCompostos.Meses);
juros = Math.Truncate(juros * 100) / 100;
return(juros);
}
public string CalcularJuros(JurosCompostos jurosCompostos)
{
double valorJuros = RunAsync();
var valorResults = jurosCompostos.ValorInicial * (Math.Pow((Constantes.VALOR_UNICO + valorJuros), jurosCompostos.Tempo));
return(valorResults.ToString("#.##"));
}
public void SeValorInicialZerado_ValorFinalZerado()
{
var juros = new JurosCompostos
{
Juros = 0.01D,
Tempo = 5
};
Assert.AreEqual(Convert.ToDecimal(juros.ValorFinal), Convert.ToDecimal(0));
}
public void SeTempoZerado_ValorFinalIgualAoInicial()
{
var juros = new JurosCompostos
{
Juros = 0.01D,
ValorInicial = 100,
};
Assert.AreEqual(Convert.ToDecimal(juros.ValorFinal), juros.ValorInicial);
}
public void SeJurosIgualAZero_ValorFinalIgualAoInicial()
{
var juros = new JurosCompostos
{
ValorInicial = 100,
Tempo = 5
};
Assert.AreEqual(Convert.ToDecimal(juros.ValorFinal), juros.ValorInicial);
}
public void Metodo_Calcular_Juros_Compostos_Deve_Retornar_105_10()
{
var juros = new JurosCompostos()
{
ValorInicial = 100,
Meses = 5,
TaxaJuros = 0.01m
};
Assert.Equal(105.10m, juros.JurosCompostosCalculado);
}
public void RetornaCalculoCorreto()
{
var juros = new JurosCompostos
{
Juros = 0.01D,
ValorInicial = 100,
Tempo = 5
};
Assert.AreEqual(Convert.ToDecimal(juros.ValorFinal), Convert.ToDecimal(105.10D));
}
public async Task Get_CalcularJuro_RetornaDouble()
{
double taxa = 0.53;
double valorInicial = 200.7;
int meses = 10;
JurosCompostos jurosCompostos = new JurosCompostos(valorInicial, meses, taxa);
var consultaJuros = new ConsultaJurosMock(taxa);
CalculoJurosComposto calculoJuro = new CalculoJurosComposto(consultaJuros, valorInicial, meses);
var valor = calculoJuro.CalcularJuroComposto(jurosCompostos);
Assert.Equal <double>(14107.87, valor);
}
public void Deve_Calcular_Juros_Compostos()
{
// Arrange
var tempo = TempoEmMeses.Criar(5).Value;
decimal taxa = 0.01m;
decimal valorInicial = 100m;
// Act
var valorCalculado = JurosCompostos.Calcular(valorInicial, tempo, taxa);
// Assert
Assert.Equal(105.10100501m, valorCalculado);
}
public async Task <JsonResultBase <JurosCompostosViewModel> > CalcularJurosCompostosAsync(JurosCompostosInput input)
{
var result = new JsonResultBase <JurosCompostosViewModel>();
var validarParametros = ValidarParametrosJurosCompostos(input.ValorInicial, input.Meses);
if (validarParametros.Any())
{
result.Data = null;
result.Error = true;
result.Messages = validarParametros;
return(result);
}
var jurosCompostos = new JurosCompostos()
{
TaxaJuros = 0,
Meses = input.Meses,
ValorInicial = input.ValorInicial
};
var jurosCalculado = await _jurosCompostosDomainService.CalcularJurosCompostosAsync(jurosCompostos);
if (jurosCalculado == null)
{
var errorMsg = new ValidationMessageBase()
{
Message = "Não foi possível calcular o juros."
};
var listMsg = new List <ValidationMessageBase>();
listMsg.Add(errorMsg);
result.Data = null;
result.Error = true;
result.Messages = listMsg;
return(result);
}
var data = new JurosCompostosViewModel()
{
ValorInicial = input.ValorInicial,
Meses = input.Meses,
JurosCompostosCalculado = jurosCalculado.JurosCompostosCalculado,
TaxaJuros = jurosCalculado.TaxaJuros
};
result.Data = data;
result.Error = false;
return(result);
}
public async Task <JurosCompostos> CalcularJurosCompostosAsync(JurosCompostos jurosCompostos)
{
var taxaJuros = await ObterTaxaDeJurosApiOneAsync();
if (taxaJuros > 0)
{
jurosCompostos.TaxaJuros = taxaJuros;
jurosCompostos.CalcularJurosCompostos();
return(jurosCompostos);
}
;
return(default(JurosCompostos));
}
