public Task Handle(AtualizarContaCommand request, CancellationToken cancellationToken)
{
var contaExistente = _contaRepository.ObterPorId(request.Id);
if (contaExistente == null)
{
_mediator.PublicarEvento(new DomainNotification(request.MessageType, "Esta conta não existe."));
return(Task.CompletedTask);
}
if (contaExistente.IdUsuario != _user.GetUserId())
{
_mediator.PublicarEvento(new DomainNotification(request.MessageType, "Conta não pertencente ao usuário"));
return(Task.CompletedTask);
}
var conta = Conta.ContaFactory.NovaConta(request.Id, request.Nome, request.Data, request.Valor, request.Parcelado, request.NumeroParcelas, request.Observacao, request.IdCategoria, request.IdUsuario);
if (!IsValid(conta))
{
return(Task.CompletedTask);
}
_contaRepository.Atualizar(conta);
if (Commit())
{
_mediator.PublicarEvento(new ContaAtualizadaEvent(conta.Id, conta.Nome, conta.Data, conta.Valor, conta.Parcelado, conta.NumeroParcelas, conta.Observacao));
}
return(Task.CompletedTask);
}
public void Transferir(Tansferencia transferencia)
{
//TODO:Adicionar Regra de negocio aqui.
var ContaOrigemExistente = _contaRepository.Buscar(x => x.NumeroConta == transferencia.ContaOrigem).FirstOrDefault();
var ContaDestinoExistente = _contaRepository.Buscar(x => x.NumeroConta == transferencia.ContaDestino).FirstOrDefault();
if (ContaOrigemExistente == null)
{
throw new Exception("Conta Origem não encontrada!");
}
if (ContaOrigemExistente == null)
{
throw new Exception("Conta Destino não encontrada!");
}
if ((ContaOrigemExistente.Saldo - transferencia.Valor) < 0)
{
throw new Exception("Conta Origem não tem Saldo para efetuar esta operação!");
}
ContaOrigemExistente.Saldo = (ContaOrigemExistente.Saldo - transferencia.Valor);
_contaRepository.Atualizar(ContaOrigemExistente);
ContaDestinoExistente.Saldo = (ContaDestinoExistente.Saldo + transferencia.Valor);
_contaRepository.Atualizar(ContaDestinoExistente);
}
public void AtivarConta(Guid Id)
{
var conta = _contaRepository.ObterPorId(Id);
conta.Ativar();
_contaRepository.Atualizar(conta);
Commit();
}
public async Task <Conta> Depositar(EntradaContaDTO conta)
{
var contaBd = await _repository.PegarConta(conta.Conta);
if (contaBd != null)
{
contaBd.Saldo += conta.Saldo;
return(await _repository.Atualizar(contaBd));
}
return(null);
}
public Task <bool> Handle(AdicionarValorSaldoContaCommand request, CancellationToken cancellationToken)
{
var conta = ObterContaExistente(request.ContaId);
if (conta == null)
{
return(Falha());
}
conta.AdicionarValorSaldo(request.Valor);
_contaRepository.Atualizar(conta);
return(Sucesso());
}
public bool ProcessarTransacao(ContaTransacaoDTO transacaoDTO)
{
var listaDeContas = _conta.ListarContas(transacaoDTO.AgContaOrigem, transacaoDTO.NumContaOrigem, transacaoDTO.AgContaDestino, transacaoDTO.NumContaDestino);
var ContaOrigem = listaDeContas.Find(c => c.ContaAgencia == transacaoDTO.AgContaOrigem && c.ContaNumero == transacaoDTO.NumContaOrigem);
var ContaDestino = listaDeContas.Find(c => c.ContaAgencia == transacaoDTO.AgContaDestino && c.ContaNumero == transacaoDTO.NumContaDestino);
if (ContaOrigem == null || ContaDestino == null)
{
throw new ArgumentException("Ocorreu uma falha na transação");
}
ContaMovimentoHistoricoDTO movimentoHistoricoContaOrigemDTO = new ContaMovimentoHistoricoDTO()
{
CdConta = ContaOrigem.CdConta,
AgConta = ContaOrigem.ContaAgencia,
NumConta = ContaOrigem.ContaNumero,
SaldoAnterior = ContaOrigem.Saldo,
SaldoAtual = (ContaOrigem.Saldo - transacaoDTO.ValorOperacao),
TipoOperacao = (int)TipoOperacaoEnum.Debito,
ValorOperacao = transacaoDTO.ValorOperacao,
DataOperacao = transacaoDTO.DataOperacao
};
ContaMovimentoHistoricoDTO movimentoHistoricoContaDestinoDTO = new ContaMovimentoHistoricoDTO()
{
CdConta = ContaDestino.CdConta,
AgConta = ContaDestino.ContaAgencia,
NumConta = ContaDestino.ContaNumero,
SaldoAnterior = ContaDestino.Saldo,
SaldoAtual = (ContaDestino.Saldo + transacaoDTO.ValorOperacao),
TipoOperacao = (int)TipoOperacaoEnum.Credito,
ValorOperacao = transacaoDTO.ValorOperacao,
DataOperacao = transacaoDTO.DataOperacao
};
ContaOrigem.Saldo -= transacaoDTO.ValorOperacao;
ContaDestino.Saldo += transacaoDTO.ValorOperacao;
_conta.Atualizar(ContaOrigem);
_conta.Atualizar(ContaDestino);
_historico.Salvar(movimentoHistoricoContaOrigemDTO);
_historico.Salvar(movimentoHistoricoContaDestinoDTO);
return(true);
}
public void Atualizar(ContaViewModel model)
{
var domain = _mapper.Map <Conta>(model);
if (!Notifications.HasNotifications())
{
_contaRepository.Atualizar(domain);
if (!Commit())
{
//todo: falha ao salvar
}
}
}
public async Task <bool> Salvar(AlteracaoViewModel viewModel)
{
var conta = new Conta(viewModel.Nome, Enum.Parse <ESexoConta>(viewModel.Sexo), viewModel.DataNascimento, viewModel.CPF, viewModel.PlanoId);
conta.Id = viewModel.Id;
var usuario = await _userManager.FindByIdAsync(viewModel.IdUsuario);
_contaRepository.Atualizar(viewModel.Id, conta);
var resultadoCommit = _uow.Commit();
if (resultadoCommit == false)
{
return(resultadoCommit);
}
if (!String.IsNullOrEmpty(viewModel.Senha))
{
var resultadoIdentity = await _userManager.ChangePasswordAsync(usuario, viewModel.SenhaAntiga, viewModel.Senha);
return(resultadoIdentity.Succeeded);
}
return(true);
}
public void Handle(AtualizarContaCommand message)
{
if (!CommandValido(message))
{
return;
}
Conta conta = new Conta(message.Responsavel, message.Documento, message.NomeFantasia,
new Core_AppStyle_Conta(message.LogoUri, message.Sobre, message.Informacoes, message.Ajuda));
_contaRepository.Atualizar(conta);
if (!Commit())
{
return;
}
}
public void Executar()
{
if (Conta != null)
{
if (Conta.Valor != 0)
{
var lConta = _contaRepository.Buscar(x => x.NumeroConta == Conta.NumeroConta).First();
if (lConta != null)
{
lConta.Valor += Conta.Valor;
_contaRepository.Atualizar(lConta);
var lHistorico = new HistoricoTransacao
{
Conta = _contaRepository.ObterPorId(Conta.ID),
TipoOperacao = ETipoOperacao.Deposito,
};
_historicoTransacaoRepository.Adicionar(lHistorico);
}
else
{
throw new Exception("Conta informada não existe.");
}
}
else
{
throw new Exception("Valor de deposito precisar ser mais que R$ 0.00");
}
}
else
{
throw new Exception("Conta inválida.");
}
}
public void Atualizar(Conta entity)
{
_contaRepository.Atualizar(entity);
}
public void Atualizar(ContaDTO conta)
{
_repository.Atualizar(conta);
}
public async Task <bool> Handle(AdicionarLancamentoCommand request, CancellationToken cancellationToken)
{
var lancamento = new Lancamentos(request.Valor);
var titularContaOrigem = _contaRepository.ObterTitularDaContaPorCPF(request.OrigemConta.Cpf).Result;
var titularContaDestino = _contaRepository.ObterTitularDaContaPorCPF(request.DestinoConta.Cpf).Result;
if (request.OrigemConta.Cpf.Equals(request.DestinoConta.Cpf) &&
request.OrigemConta.Numero.Equals(request.DestinoConta.Numero))
{
Notificar("Conta origem e destino possuem os mesmos dados, verifique o cpf e o numero da conta");
return(false);
}
if (titularContaOrigem == null)
{
Notificar("Conta origem não existe no CPF informado");
}
if (titularContaDestino == null)
{
Notificar("Conta destino não existe no CPF informado");
}
if (ExisteNotificacao())
{
return(false);
}
var contaO = ContaCorrente.ContaFactory.AtualizarConta(
titularContaOrigem.ContaId,
titularContaOrigem.Id,
titularContaOrigem,
titularContaOrigem.ContaCorrente.Numero,
titularContaOrigem.ContaCorrente.Saldo);
var contaD = ContaCorrente.ContaFactory.AtualizarConta(
titularContaDestino.ContaId,
titularContaDestino.Id,
titularContaDestino,
titularContaDestino.ContaCorrente.Numero,
titularContaDestino.ContaCorrente.Saldo);
lancamento.AtribuirConta(contaO);
if (!ExecutarValidacao(lancamento) ||
!ExecutarValidacao(contaO) ||
!ExecutarValidacao(contaD))
{
return(false);
}
contaO.RealizarTransferencia(contaD, lancamento);
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await _contaRepository.Atualizar(contaO);
await _contaRepository.Atualizar(contaD);
await _lancamentoRepository.Adicionar(lancamento);
scope.Complete();
scope.Dispose();
}
return(true);
}
public Conta Atualizar(Conta conta)
{
return(_contaRepository.Atualizar(conta));
}
public void Transferir(TransferenciaDTO transferenciaDTO)
{
var notificacoes = transferenciaDTO.Validar();
if (notificacoes.Any())
{
NotificarErroNegocio(notificacoes);
return;
}
var contaOrigem = _contaRepository.Buscar
(
transferenciaDTO.BancoOrigem,
transferenciaDTO.ContaOrigem,
transferenciaDTO.AgenciaOrigem
);
if (contaOrigem == null)
{
NotificarErroNegocio("Conta de origem não encontrada");
return;
}
var contaDestino = _contaRepository.Buscar
(
transferenciaDTO.BancoDestino,
transferenciaDTO.ContaDestino,
transferenciaDTO.AgenciaDestino
);
if (contaDestino == null)
{
NotificarErroNegocio("Conta de Destino não encontrada");
return;
}
if (!contaOrigem.Debitar(transferenciaDTO.Valor))
{
NotificarErroNegocio("Saldo insuficiente para completar a operação");
return;
}
contaDestino.Creditar(transferenciaDTO.Valor);
var lancamento = new Lancamento
{
ContaDestino = contaDestino,
ContaOrigem = contaOrigem,
Data = DateTime.Now,
Valor = transferenciaDTO.Valor
};
_contaRepository.Atualizar(contaOrigem);
_contaRepository.Atualizar(contaDestino);
_contaRepository.AdicionarLancamento(lancamento);
try
{
_unitOfWork.Commit();
}
catch (Exception ex)
{
NotificarErroInterno(ex.Message);
}
}
