public IActionResult InserirTransacao([Bind("IdConta,Valor,IdTipoTransacao")] InserirTransacaoViewModel transacaoParam)
{
if (!ModelState.IsValid)
{
return(View(transacaoParam));
}
try
{
var transacao = new TransacaoDTO()
{
IdConta = transacaoParam.IdConta,
IdTipoTransacao = transacaoParam.IdTipoTransacao,
Valor = transacaoParam.Valor,
DataHora = DateTime.Now,
};
_transacaoDominio.Inserir(transacao);
return(Ok(MensagemResposta.TransacaoInseridaSucesso));
}
catch (ArgumentException argumentEx)
{
return(BadRequest(argumentEx.Message));
}
}
public ActionResult <RetornoTransacaoDTO> Post(TransacaoDTO transacao)
{
RetornoTransacao retorno = new TransactionService().RealizarTransacao(transacao.cartao, transacao.valor, transacao.tipo, transacao.parcelas, transacao.guid);
return(new RetornoTransacaoDTO {
Codigo = (int)retorno, Descricao = GetEnumDescription(retorno)
});
}
/// <summary>
/// Realizar transação
/// </summary>
/// <param name="transacao"></param>
/// <returns></returns>
public Task <bool> RealizarTransacaoAsync(TransacaoDTO transacao)
{
transacao.ContaOrigem.Saldo = contaRepository.VerificarSaldoAsync(transacao.ContaOrigem).Result - transacao.Valor;
transacao.ContaDestino.Saldo = contaRepository.VerificarSaldoAsync(transacao.ContaDestino).Result + transacao.Valor;
transacao.Data = DateTime.Now;
listaTransacoes.Add(transacao);
return(Task.FromResult(true));
}
public async Task <IActionResult> CriarTransacaoAsync([FromBody] TransacaoDTO transacao)
{
if (transacao == null)
{
return(BadRequest("Transação nula"));
}
if (transacao.ContaDestino == null)
{
return(BadRequest("Conta destino nula"));
}
if (transacao.ContaOrigem == null)
{
return(BadRequest("Conta origem nula"));
}
if (transacao.Valor <= 0)
{
return(BadRequest("Valor da transação inválido"));
}
var contaOrigem = await contaRepository.VerificarContaExisteAtivaAsync(transacao.ContaOrigem);
var contaDestino = await contaRepository.VerificarContaExisteAtivaAsync(transacao.ContaDestino);
if (contaOrigem.Id == 0 || contaDestino.Id == 0)
{
return(BadRequest("Conta inválida"));
}
var saldoContaOrigem = await contaRepository.VerificarSaldoAsync(contaOrigem);
if (contaOrigem.Numero == transacao.ContaDestino.Numero)
{
return(BadRequest("Conta destino deve ser diferente da origem"));
}
if (transacao.Valor > saldoContaOrigem)
{
return(BadRequest("Valor excede o total da conta"));
}
var realizouTransacao = await transacaoRepository.RealizarTransacaoAsync(transacao);
if (realizouTransacao)
{
await contaRepository.DebitarValorAsync(contaOrigem, transacao.Valor);
await contaRepository.CreditarValorAsync(contaDestino, transacao.Valor);
return(Ok("Transação realizada com sucesso"));
}
return(BadRequest("Não foi possível realizar transação, verifique se as contas estão corretas!"));
}
/// <summary>
/// Realiza a validacao basica do Saldo da conta para o lancamento da transacao
/// </summary>
/// <param name="conta"></param>
/// <param name="transacaoParam"></param>
/// <param name="tipoTransacao"></param>
public void ValidarSaldo(Conta conta, TransacaoDTO transacaoParam, TipoTransacao tipoTransacao)
{
decimal valorSaldoAtual = transacaoParam.Valor * tipoTransacao.FlagSaldoAtual;
if (transacaoParam.Valor <= 0)
{
throw new ArgumentException(MensagemResposta.ValorTransacaoInvalido);
}
if (conta.SaldoAtual + valorSaldoAtual < 0)
{
throw new ArgumentException(MensagemResposta.ContaSemSaldoParaOperacao);
}
}
public ActionResult <TransacaoDTO> Post(TransacaoDTO transacao)
{
try
{
transacao.DataHora = DateTime.Now;
_transacaoDominio.Inserir(transacao);
return(transacao);
}
catch (ArgumentException argumentEx)
{
return(BadRequest(argumentEx.Message));
}
}
/// <summary>
/// Insere uma transacao nova na conta.
/// </summary>
/// <param name="transacaoParam"></param>
public void Inserir(TransacaoDTO transacaoParam)
{
var tipoTransacao = _tipoTransacaoRepositorio.BuscarTiposTransacoesPorId(transacaoParam.IdTipoTransacao);
ValidarTipoTransacao(tipoTransacao);
var conta = _contaDominio.BuscarPorId(transacaoParam.IdConta);
_contaDominio.ValidarConta(conta);
ValidarSaldo(conta, transacaoParam, tipoTransacao);
conta = AdicionarTransacao(conta, transacaoParam, tipoTransacao);
_transacaoRepositorio.InserirTransacao(conta);
}
/// <summary>
/// Realiza o calculo de rendimento e retorna a transacao que devera ser incluida.
/// </summary>
/// <param name="idConta"></param>
/// <param name="saldoAtual"></param>
/// <param name="idTipoTransacao"></param>
/// <param name="proximoRendimento"></param>
/// <returns></returns>
public TransacaoDTO CalcularRendimento(int idConta, decimal saldoAtual, int idTipoTransacao, TaxaCdi proximoRendimento)
{
var transacao = new TransacaoDTO()
{
IdConta = idConta,
IdTipoTransacao = idTipoTransacao,
Historico = proximoRendimento.Data.ToString("dd/MM/yyyy"),
DataHora = DateTime.Now,
};
decimal rendimento = saldoAtual * (proximoRendimento.Percentual * proximoRendimento.TaxaDia);
transacao.Valor = Math.Round(rendimento, 2);
return(transacao);
}
public async Task <int> RegistrarTransacao(TransacaoDTO transacao)
{
StringBuilder queryRegistraTransacao = new StringBuilder();
queryRegistraTransacao.AppendLine("insert into transacao (ID_Curso,Valor,Data,Email_Usuario) values ");
queryRegistraTransacao.AppendFormat("{0},{1},'{2}','{3}'", transacao.ID_Curso, transacao.Valor, transacao.DataTransacao.ToString(), transacao.Email_Usuario);
try
{
await UtilitarioDatabase.ExecutarComando(queryRegistraTransacao.ToString());
return(200);
}
catch
{
return(500);
}
}
/// <summary>
/// Realiza os procedimentos necessarios para inclusao de uma nova transacao na conta.
/// </summary>
/// <param name="conta"></param>
/// <param name="transacaoParam"></param>
/// <param name="tipoTransacao"></param>
/// <returns></returns>
public Conta AdicionarTransacao(Conta conta, TransacaoDTO transacaoParam, TipoTransacao tipoTransacao)
{
decimal valorSaldoAtual = transacaoParam.Valor * tipoTransacao.FlagSaldoAtual;
conta.SaldoAtual = conta.SaldoAtual + valorSaldoAtual;
conta.Transacao.Add(new Transacao
{
IdConta = transacaoParam.IdConta,
DataHora = transacaoParam.DataHora,
IdTipoTransacao = transacaoParam.IdTipoTransacao,
Valor = Math.Round(transacaoParam.Valor, 2),
Historico = transacaoParam.Historico,
});
return(conta);
}
public IActionResult Pagar(int id, TransacaoDTO dto)
{
dto.ContaCorrenteId = id;
try
{
var resultadoValidacao = _serviceContaCorrente.Pagar(dto);
return(Ok(new ResponseDTO
{
Success = resultadoValidacao.Valido,
Message = resultadoValidacao.Erros
}));
}
catch (Exception ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IActionResult> Post([FromBody] TransacaoDTO transacaoDTO)
{
try
{
if (transacaoDTO == null)
{
return(NotFound());
}
await _transacaoCommand.AddReal(transacaoDTO);
return(Ok("Ação enviada para armazenamento do DB efetuada com sucesso!"));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> PostProducer([FromBody] TransacaoDTO transacaoDTO)
{
try
{
if (transacaoDTO == null)
{
return(NotFound());
}
await _transacaoCommand.AddProducer(transacaoDTO);
return(Ok("Ação enviada para produção do Kafk efetuada com sucesso!"));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task AddReal(TransacaoDTO transacao)
{
var model = transacao.ConvertTo <Transacao>();
await _transacaoService.EfetuarAcao(model);
}
private ValidacaoDTO RegistrarTransacao(TransacaoDTO transacao)
{
return(UtilitarioHTTP.InterpretarStatusCode(this.cursoRepositorio.RegistrarTransacao(transacao).Result));
}
public async Task AddProducer(TransacaoDTO transacao)
{
var output = JsonConvert.SerializeObject(transacao);
await _producer.SendDataAsync(ProjectConsts.TOPIC_NAME, output);
}
public ResultadoValidacao Resgatar(TransacaoDTO dto)
{
return(_serviceContaCorrente.Resgatar(dto.ContaCorrenteId, dto.Valor));
}
public Task <bool> RealizarTransacaoAsync(TransacaoDTO transacao)
{
listaTransacoes.Add(transacao);
return(Task.FromResult(true));
}
