Esempio n. 1
0
        public void Handle(AtualizarClienteCommand cmd)
        {
            Cliente cliente = ClienteExistente(cmd.Id, cmd.MessageType);

            if (cliente != null)
            {
                cliente.AtualizarCliente(cmd.Nome, cmd.Email, cmd.Telefone, cmd.Facebook, cmd.DataNascimento, cmd.Sexo, cmd.EstadoCivil, cmd.AtracaoPreferida, cmd.EstiloPreferido);

                if (!cliente.IsValid())
                {
                    NotificarValidacoesErro(cliente.ValidationResult);
                    return;
                }

                Usuario usuario = _usuarioRepository.ObterPorId(cliente.Id);
                usuario.AtualizarUsuario(cmd.Nome, cmd.Email, cmd.Senha);
                _usuarioRepository.Atualizar(usuario);
                _repository.Atualizar(cliente);

                if (Commit())
                {
                    _mediator.PublicarEvento(new ClienteAtualizadoEvent(cliente.Id, cliente.Nome, cliente.Email, cmd.Senha, cliente.Telefone, cliente.Facebook, cliente.DataNascimento, cliente.Sexo, cliente.EstadoCivil, cliente.AtracaoPreferida, cliente.EstiloPreferido));
                }
            }
        }
Esempio n. 2
0
        public Task <bool> Handle(AtualizarClienteCommand message, CancellationToken cancellationToken)
        {
            if (!message.IsValid())
            {
                NotifyValidationErrors(message);
                return(Task.FromResult(false));
            }

            var cliente = _clienteRepository.GetById(message.ClienteId);

            if (cliente == null)
            {
                _bus.RaiseEvent(new DomainNotification(message.MessageType, "Cliente não cadastrado.", message));
                return(Task.FromResult(false));
            }

            cliente.Update(message.Cpf, message.NomeCompleto, message.DataNascimento, message.Email,
                           message.TelefoneFixo, message.TelefoneCelular, message.ConsultorId);

            _clienteRepository.Update(cliente);

            var clienteFontePagadora = cliente.FontePagadora?.Update(message.InssNumeroBeneficio, message.InssSalario, message.InssEspecie, message.OutrosDiaPagamento);

            if (clienteFontePagadora != null)
            {
                _clienteFontePagadoraRepository.Update(clienteFontePagadora);
            }

            if (Commit())
            {
            }

            return(Task.FromResult(true));
        }
Esempio n. 3
0
        public void AtualizarCliente(Guid clienteId, string cpf, string nomeCompleto, DateTime dataNascimento, string email,
                                     string telefoneFixo, string telefoneCelular, Guid?consultorId,
                                     long?inssNumeroBeneficio, double?inssSalario, int?inssEspecie, int?outrosDiaPagamento)
        {
            var atualizarClienteCommand = new AtualizarClienteCommand(clienteId, cpf, nomeCompleto, dataNascimento, email,
                                                                      telefoneFixo, telefoneCelular, consultorId,
                                                                      inssNumeroBeneficio, inssSalario, inssEspecie, outrosDiaPagamento);

            _bus.SendCommand(atualizarClienteCommand);
        }
        public void AtualizarClienteIdClienteNaoInformado()
        {
            var clienteServiceMock = new ClienteServicoMock();
            var clienteServico     = clienteServiceMock.ConfigurarAtualizarSucesso().Build();

            var atualizarCommand = new AtualizarClienteCommand(clienteServico, new AtualizarClienteValidador(clienteServico));

            Assert.ThrowsAsync <ArgumentException>(() => atualizarCommand.Executar(new AtualizarClientesInput
            {
                ClienteId = 0
            }));
        }
        public void AtualizarClienteSucesso()
        {
            var clienteServiceMock = new ClienteServicoMock();
            var clienteServico     = clienteServiceMock.ConfigurarAtualizarSucesso().Build();

            var atualizarCommand = new AtualizarClienteCommand(clienteServico, new AtualizarClienteValidador(clienteServico));

            Assert.DoesNotThrowAsync(() => atualizarCommand.Executar(new AtualizarClientesInput
            {
                ClienteId = 1
            }));
        }
Esempio n. 6
0
        public CommandResult Atualizar(AtualizarClienteCommand command)
        {
            string entityName = "Cliente";

            try
            {
                command.Validate();
                if (command.Invalid)
                {
                    return(CommandResult.Invalid(command.Notifications.ToNotificationsString()));
                }

                Cliente cliente = dataContext.Cliente.FirstOrDefault(x => x.Cod_Cliente == command.Cod_Cliente);

                if (cliente is null)
                {
                    return(CommandResult.Invalid(Logs.EntidadeNaoEncontrada(entityName, command.Cod_Cliente)));
                }



                cliente.Atualizar(
                    DataString.FromString(command.CPF_CNPJ),
                    DataString.FromString(command.NomeCompleto_RazaoSocial),
                    DataString.FromString(command.Fantasia),
                    DataString.FromNullableString(command.Insc_Estadual),
                    DataString.FromNullableString(command.Logradouro),
                    DataString.FromNullableString(command.Endereco),
                    DataString.FromNullableString(command.Bairro),
                    DataString.FromNullableString(command.Complemento),
                    DataString.FromNullableString(command.Cidade),
                    DataString.FromNullableString(command.CEP),
                    DataString.FromNullableString(command.UF),
                    DataString.FromNullableString(command.Telefones),
                    DataString.FromNullableString(command.Funcao),
                    command.Flag_Ativo,
                    command.Email,
                    DataString.FromNullableString(command.Observacao),
                    DataString.FromNullableString(command.Referencia));

                dataContext.SaveChanges();
                return(CommandResult.Valid());
            }
            catch (Exception ex)
            {
                return(CommandResult.Invalid(ex.Message));
            }
        }
Esempio n. 7
0
 public Task <IActionResult> Put(Guid id, [FromBody] AtualizarClienteCommand customer)
 {
     return(Task.Run(async() =>
     {
         IActionResult result = NotFound();
         var record = await _customerService.GetCustomerAsync(id);
         if (record != null)
         {
             customer.Id = id;
             bool updated = await _customerService.IssueCommandAsync(customer);
             if (updated)
             {
                 result = NoContent();
             }
         }
         return result;
     }));
 }
Esempio n. 8
0
 public Task Handle(AtualizarClienteCommand notification, CancellationToken cancellationToken)
 {
     return(Task.CompletedTask);
 }
Esempio n. 9
0
 public IActionResult Atualizar(
     [FromServices] IClienteService service,
     [FromBody] AtualizarClienteCommand command)
 {
     return(Result(service.Atualizar(command)));
 }
Esempio n. 10
0
 public async Task <ActionResult> Put([FromRoute] Guid codigo, AtualizarClienteCommand command)
 {
     command.Codigo = codigo;
     return(RespostaCasoDeUso(await _mediator.Send(command)));
 }