// ADICIONAR
public async Task <HistoricoDto> Add(HistoricoDto historicoDto)
{
var historico = _map.Map <Historico>(historicoDto);
_repo.Add(historico);
if (await _repo.SaveAsync())
{
return(_map.Map <HistoricoDto>(historico));
}
throw new ArgumentException("Erro ao persitir no banco!");
}
public async Task <IActionResult> RegistrarHistorico(HistoricoDto historicoDto)
{
var edicao = await contexto.Edicoes
.Include(x => x.Historicos)
.FirstOrDefaultAsync(x => x.Status == StatusDaEdicao.Aberta);
edicao.RegistrarHistorico(historicoDto);
await contexto.SaveChangesAsync();
return(Ok());
}
// REALIZAR SAQUE
public async Task <ContaDto> Saque(HelperContaDto contaSaque)
{
var conta = await _repo.GetByAgenciaAndContaCorrente(contaSaque.Agencia, contaSaque.Conta);
if (conta == null || conta.Saldo <= 0)
{
throw new NotFoundException("Nenhumca conta encontrada e/ou saldo insuficiente!");
}
bool senhaConfere = CompareSenha(contaSaque.Senha, conta.Senha);
if (!senhaConfere)
{
throw new ArgumentException("Senha incorreta!");
}
conta.Saldo -= contaSaque.Quantia;
_repo.Update(conta);
if (await _repo.SaveAsync())
{
// INSERT NO HISTORICO
HistoricoDto historicoDto = new HistoricoDto
{
DescricaoTransacao = "SAQUE CONTA CORRENTE",
DigitosConta = conta.DigitosConta,
DigitosAgencia = conta.DigitosAgencia,
TipoConta = 0,
Valor = contaSaque.Quantia,
DataTransacao = DateTime.Now,
NomeConta = conta.NomeConta,
Operacao = 0,
};
// SERVICE ADD DO HISTORICO
var historicoAdd = await _historicoServices.Add(historicoDto);
// INSERT EM HISTORICOCONTAS
HistoricosContasDto historicosContasDto = new HistoricosContasDto
{
ContaId = conta.Id,
HistoricoId = historicoAdd.Id,
DataCriacao = DateTime.Now
};
var addHistoricosContas = _map.Map <HistoricosContas>(historicosContasDto);
_repoHistoricosContas.Add(addHistoricosContas);
if (await _repoHistoricosContas.SaveAsync())
{
return(_map.Map <ContaDto>(conta));
}
}
// SE SAIR DE TODOS IF E PQ DEU ERRO AO PERSISTIR DADOS
throw new ArgumentException("Erro ao persitir dados no banco!");
}
// REALIZAR DEPOSITO
public async Task <ContaDto> Depositar(HelperContaDto contaDto)
{
// OBTER A CONTA CORRENTE
var conta = await _repo.GetByAgenciaAndContaCorrente(contaDto.Agencia, contaDto.Conta);
if (conta == null)
{
throw new NotFoundException("Nehuma conta encontrada!!");
}
bool senhaConfere = CompareSenha(contaDto.Senha, conta.Senha);
if (!senhaConfere)
{
throw new ArgumentException("Senha incorreta!");
}
conta.Saldo += contaDto.Quantia;
_repo.Update(conta);
if (await _repo.SaveAsync())
{
HistoricoDto historicoDto = new HistoricoDto
{
DataTransacao = DateTime.Now,
TipoConta = 0,
DescricaoTransacao = "DEPOSITO EM CONTA CONRRENTE",
DigitosAgencia = conta.DigitosAgencia,
DigitosConta = conta.DigitosConta,
Valor = contaDto.Quantia,
NomeConta = conta.NomeConta,
Operacao = 1
};
var addHistorico = await _historicoServices.Add(historicoDto);
HistoricosContasDto historicosContasDto = new HistoricosContasDto
{
ContaId = conta.Id,
DataCriacao = DateTime.Now,
HistoricoId = addHistorico.Id
};
var historicosContas = _map.Map <HistoricosContas>(historicosContasDto);
_repoHistoricosContas.Add(historicosContas);
if (await _repoHistoricosContas.SaveAsync())
{
return(_map.Map <ContaDto>(conta));
}
}
throw new ArgumentException("Erro ao persistir no banco");
}
public async Task <IActionResult> Add(HistoricoDto historicoDto)
{
try
{
var addHistorico = await _service.Add(historicoDto);
return(Created($"/api/historico/{addHistorico.Id}", addHistorico));
}
catch (ArgumentException e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"${e.Message}"));
}
}
public async Task <IActionResult> Update(HistoricoDto historicoDto)
{
try
{
var updateHistorico = await _service.Update(historicoDto);
return(Ok(updateHistorico));
}
catch (NotFoundException e)
{
return(this.StatusCode(StatusCodes.Status404NotFound, $"${e.Message}"));
}
catch (ArgumentException e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, $"${e.Message}"));
}
}
// ATUALIZAR
public async Task <HistoricoDto> Update(HistoricoDto historicoDto)
{
var historico = await _repo.GetByIdAsync(historicoDto.Id);
if (historico == null)
{
throw new NotFoundException("Nenhum extrato encontrado com esse id!");
}
_map.Map(historico, historicoDto);
_repo.Update(historico);
if (await _repo.SaveAsync())
{
return(_map.Map <HistoricoDto>(historico));
}
throw new ArgumentException("Erro ao persitir no banco!");
}
public void RegistrarHistorico(HistoricoDto historicoDto)
{
var historico = new Historico(historicoDto.TimeId, historicoDto.CartaId, historicoDto.Observacao, this);
this.Historicos.Add(historico);
}
// REALIZAR APLICACAO NA POUPANCA
public async Task <ContaDto> ResgatarPoupanca(HelperContaDto contaDto)
{
// CONTA CORRENTE
var contaCorrente = await _repo.GetByAgenciaAndContaCorrente(contaDto.Agencia, contaDto.Conta);
// CONTA POUPANCA
var contaPoupanca = await _repo.GetByAgenciaAndContaPoupanca(contaDto.Agencia, contaDto.Conta);
if (contaCorrente == null && contaPoupanca == null)
{
throw new NotFoundException("Conta corrente e/ou Conta Poupanca não encontrada!");
}
else if (contaPoupanca.Saldo < contaDto.Quantia)
{
throw new NotFoundException("Saldo insuficiente!");
}
bool senhaConfere = CompareSenha(contaDto.Senha, contaPoupanca.Senha);
if (!senhaConfere)
{
throw new ArgumentException("Senha incorreta!");
}
contaCorrente.Saldo += contaDto.Quantia;
contaPoupanca.Saldo -= contaDto.Quantia;
List <Conta> contas = new List <Conta>();
contas.Add(contaCorrente);
contas.Add(contaPoupanca);
_repo.UpdateRange(contas);
if (await _repo.SaveAsync())
{
HistoricoDto historicoCorrenteDto = new HistoricoDto
{
DataTransacao = DateTime.Now,
DescricaoTransacao = "RECEBIMENTO DE RESGATE DA POUPANCA",
DigitosAgencia = contaCorrente.DigitosAgencia,
DigitosConta = contaCorrente.DigitosConta,
DigitosAgenciaDestino = contaPoupanca.DigitosAgencia,
DigitosContaDestino = contaPoupanca.DigitosConta,
TipoConta = 0,
Valor = contaDto.Quantia,
Operacao = 3,
NomeConta = contaCorrente.NomeConta
};
var historicoContaCorrenteAdd = await _historicoServices.Add(historicoCorrenteDto);
HistoricoDto historicoPoupancaDto = new HistoricoDto
{
DataTransacao = DateTime.Now,
DescricaoTransacao = "RESGATE DE VALOR DA CONTA POUPANCA",
DigitosAgencia = contaCorrente.DigitosAgencia,
DigitosConta = contaCorrente.DigitosConta,
DigitosAgenciaDestino = contaPoupanca.DigitosAgencia,
DigitosContaDestino = contaPoupanca.DigitosConta,
TipoConta = 1,
Valor = contaDto.Quantia,
Operacao = 3,
NomeConta = contaPoupanca.NomeConta
};
var historicoContaPoupancaAdd = await _historicoServices.Add(historicoPoupancaDto);
HistoricosContasDto historicosContasCorrenteDto = new HistoricosContasDto
{
HistoricoId = historicoContaCorrenteAdd.Id,
ContaId = contaCorrente.Id,
DataCriacao = DateTime.Now
};
HistoricosContasDto historicosContasPoupancaDto = new HistoricosContasDto
{
HistoricoId = historicoContaPoupancaAdd.Id,
ContaId = contaPoupanca.Id,
DataCriacao = DateTime.Now
};
var historicosContasCorrente = _map.Map <HistoricosContas>(historicosContasCorrenteDto);
var historicosContasPoupanca = _map.Map <HistoricosContas>(historicosContasPoupancaDto);
List <HistoricosContas> listHistoricosContas = new List <HistoricosContas>();
listHistoricosContas.Add(historicosContasCorrente);
listHistoricosContas.Add(historicosContasPoupanca);
_repoHistoricosContas.AddRange(listHistoricosContas);
if (await _repoHistoricosContas.SaveAsync())
{
return(_map.Map <ContaDto>(contaCorrente));
}
}
throw new ArgumentException("Erro ao persistir no banco de dados!");
}
public async Task <ContaDto> Transferencia(HelperContaDto contaDto)
{
// CONTA QUE IRA MANDAR A TRANSFERENCIA
var contaOrigin = await _repo.GetByAgenciaAndContaCorrente(contaDto.Agencia, contaDto.Conta);
// CONTA QUE IRA RECEBER A TRANSFERENCIA
var contaDestino = await _repo.GetByAgenciaAndContaCorrente(contaDto.AgenciaDestino, contaDto.ContaDestino);
await ExistContaFindByCPF(contaDto);
// SE O REGISTRO RETORNA COMO NULL
if (contaOrigin == null || contaDestino == null)
{
throw new NotFoundException("Conta origin nao encontrada e/ou conta destino nao encontrada!");
}
else if (contaDto.Quantia > contaOrigin.Saldo)
{
throw new NotFoundException("Saldo Insuficiente!");
}
bool senhaConfere = CompareSenha(contaDto.Senha, contaOrigin.Senha);
if (!senhaConfere)
{
throw new ArgumentException("Senha incorreta!");
}
contaOrigin.Saldo -= contaDto.Quantia;
contaDestino.Saldo += contaDto.Quantia;
List <Conta> contas = new List <Conta>();
contas.Add(contaOrigin);
contas.Add(contaDestino);
_repo.UpdateRange(contas);
if (await _repo.SaveAsync())
{
HistoricoDto historicoOriginDto = new HistoricoDto
{
DataTransacao = DateTime.Now,
DescricaoTransacao = "TRANSFERENCIA BANCARIA PARA CONTA CORRENTE",
DigitosAgencia = contaOrigin.DigitosAgencia,
DigitosConta = contaOrigin.DigitosConta,
DigitosAgenciaDestino = contaDestino.DigitosAgencia,
DigitosContaDestino = contaDestino.DigitosConta,
TipoConta = 0,
Valor = contaDto.Quantia,
NomeConta = contaOrigin.NomeConta,
NomeContaDestino = contaDestino.NomeConta,
Operacao = 4
};
var historicoAdd = await _historicoServices.Add(historicoOriginDto);
HistoricoDto historicoDestinoDto = new HistoricoDto
{
DataTransacao = DateTime.Now,
DescricaoTransacao = "RECEBIMENTO DE TRANSFERENCIA BANCARIA",
DigitosAgencia = contaOrigin.DigitosAgencia,
DigitosConta = contaOrigin.DigitosConta,
DigitosAgenciaDestino = contaDestino.DigitosAgencia,
DigitosContaDestino = contaDestino.DigitosConta,
TipoConta = 0,
Valor = contaDto.Quantia,
NomeConta = contaOrigin.NomeConta,
NomeContaDestino = contaDestino.NomeConta,
};
var historicoDestinoAdd = await _historicoServices.Add(historicoDestinoDto);
HistoricosContasDto historicosContasDestinoDto = new HistoricosContasDto
{
ContaId = contaDestino.Id,
HistoricoId = historicoDestinoAdd.Id,
DataCriacao = DateTime.Now
};
HistoricosContasDto historicosContasDto = new HistoricosContasDto
{
ContaId = contaOrigin.Id,
HistoricoId = historicoAdd.Id,
DataCriacao = DateTime.Now
};
var historicosContas = _map.Map <HistoricosContas>(historicosContasDto);
var historicosContasDestino = _map.Map <HistoricosContas>(historicosContasDestinoDto);
List <HistoricosContas> listHistoricosContas = new List <HistoricosContas>();
listHistoricosContas.Add(historicosContas);
listHistoricosContas.Add(historicosContasDestino);
_repoHistoricosContas.AddRange(listHistoricosContas);
if (await _repoHistoricosContas.SaveAsync())
{
bool existeContaCadastrada = await _contaCadastradaService.ExisteContaCadastrada(contaDestino.Id, contaOrigin.PessoaId);
if (!existeContaCadastrada)
{
ContaCadastradaDto contaCadastradaDto = new ContaCadastradaDto
{
ContaId = contaDestino.Id,
PessoaId = contaOrigin.PessoaId
};
await _contaCadastradaService.Add(contaCadastradaDto);
}
return(_map.Map <ContaDto>(contaOrigin));
}
}
throw new ArgumentException("Erro ao persistir no banco!");
}
