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); } }