public void Atualizar(Cliente cliente)
{
if (!cliente.EhValido())
{
return;
}
clienteRepository.Atualizar(cliente);
mediator.Publish(new ClienteEmailNotification("*****@*****.**", cliente.Email, "Mudanças", "Dê uma olhada!"));
}
public void Atualizar(Cliente cliente)
{
if (!cliente.EhValido())
{
return;
}
_clienteRepository.Atualizar(cliente);
_mediator.Publish(new ClienteEmailNotification("*****@*****.**", cliente.Email, "", ""));
}
public void Atualizar(Cliente cliente)
{
if (!cliente.EhValido())
{
return;
}
_clienteRepository.Atualizar(cliente);
//_mediator.Publish(new ClienteEmailNotification("*****@*****.**", cliente.Email, cliente.GetHashCode().ToString(), "cliente atualizado"));
_mediator.Publish(new ClienteEmailNotification("*****@*****.**", cliente.Email, "Mudanças", "Dê uma olhada!"));
}
public IActionResult Atualizar([FromForm] UnipDLL.BLL.Cliente cliente)
{
if (ModelState.IsValid)
{
_clienteRepository.Atualizar(cliente);
TempData["MSG_S"] = Mensagem.MSG_S001;
return(RedirectToAction(nameof(Index)));
}
ViewBag.Cursos = _cursoRepository.ObterTodosCursos().Select(a => new SelectListItem(a.Nome, a.Id.ToString()));
ViewBag.Periodos = _periodoRepository.ObterTodosPeriodos().Select(a => new SelectListItem(a.Horario, a.Id.ToString()));
return(View());
}
public async Task <ActionResult <ClienteViewModel> > AtualizarCliente(Guid?id, ClienteViewModel clienteViewModel)
{
if (id != clienteViewModel.Id)
{
return(BadRequest("Id informado é diferente do Body"));
}
if (id == null)
{
return(BadRequest("Por favor informe um ID"));
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
//VALIDAÇÃO DE CLIENTE NÃO EXISTENTE
//var cliente = await _clienteRepository.ObterPorId(clienteViewModel.Id);
//if (cliente == null) return NotFound("Cliente informado não existe. Solicitar Cliente com ID existente");
await _clienteRepository.Atualizar(_mapper.Map <Cliente>(clienteViewModel));
return(Ok(new
{
success = true,
data = clienteViewModel
}));
}
public async Task Editar(Cliente cliente)
{
if (!ExecutarValidacao(new ClienteValidation(), cliente))
{
return;
}
var clienteAtual = await _clienteRepository.ObterPorId(cliente.Id);
if (clienteAtual == null)
{
Notificar($"Cliente não identificado no sistema.");
return;
}
if (_clienteRepository.Buscar(f => f.Documento == cliente.Documento && f.Id != cliente.Id).Result.Any())
{
Notificar($"Já existe um {cliente.GetType().Name} cadastrado para este documento.");
return;
}
clienteAtual.Documento = cliente.Documento;
clienteAtual.Email = cliente.Email;
clienteAtual.Nome = cliente.Nome;
clienteAtual.Endereco = cliente.Endereco;
clienteAtual.Telefone = cliente.Telefone;
await _clienteRepository.Atualizar(clienteAtual);
}
public async Task <ServiceResponse <ObterClienteDto> > Atualizar(AtualizarClienteDto atualizarCliente)
{
var sr = new ServiceResponse <ObterClienteDto>();
try
{
var obterCliente = await Obter(atualizarCliente.Id);
if (!obterCliente.Sucess)
{
throw new Exception();
}
var cliente = _mapper.Map <Cliente>(obterCliente.Value);
cliente.Nome = atualizarCliente.Nome;
cliente.Idade = atualizarCliente.Idade;
var response = await _clienteRepository.Atualizar(cliente);
sr.Value = _mapper.Map <ObterClienteDto>(response);
}
catch (Exception ex)
{
sr.Sucess = false;
sr.Messages.Add(ex.Message);
}
return(sr);
}
public async Task <IActionResult> Put(int clienteId, Cliente model)
{
try
{
var cliente = await _clienteRepository.ObterPorId(clienteId);
if (cliente == null)
{
return(Response("Cliente nao encontrado", false));
}
var response = await _clienteRepository.Atualizar(model);
if (response)
{
return(Response("Atualizado com sucesso!"));
}
return(Response("Erro ao adicionar", false));
}
catch (Exception ex)
{
return(ResponseErro(ex));
}
}
public IActionResult Put(ClienteEdicaoModel model, [FromServices] IClienteRepository repository)
{
if (ModelState.IsValid)
{
try
{
Cliente cliente = new Cliente();
cliente.IdCliente = model.IdCliente;
cliente.Nome = model.Nome;
cliente.Email = model.Email;
repository.Atualizar(cliente);
return(Ok($"Cliente {cliente.Nome} atualizado com sucesso"));
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
}
else
{
return(StatusCode(400, "Ocorreram erro de validação"));
}
}
public void RegistrarPagamento(Pagamento pagamento)
{
pagamento.Cliente.valorPagar -= pagamento.ValorPago;
_ClienteRepository.Atualizar(pagamento.Cliente);
_ClienteRepository.Salvar();
}
public ClienteViewModel Atualizar(ClienteViewModel clienteViewModel)
{
var cliente = Mapper.Map <Cliente>(clienteViewModel);
_clienteRepository.Atualizar(cliente);
return(clienteViewModel);
}
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));
}
}
}
public IActionResult AtualizarDados(Models.Cliente cliente)
{
ModelState.Remove("Senha");
ModelState.Remove("ConfirmacaoSenha");
ModelState.Remove("Status");
if (ModelState.IsValid)
{
Models.Cliente clienteDB = _clienteRepository.ObterCliente(_loginCliente.BuscaClienteSessao().Id);
TempData["MSG_S"] = "Dados atualizados com sucesso!";
clienteDB = _mapper.Map <Models.Cliente, Models.Cliente>(cliente, clienteDB);
_clienteRepository.Atualizar(clienteDB);
return(RedirectToAction(nameof(AtualizarDados)));
}
return(View());
}
public ICommandResult Handle(AtualizaClienteCommand command)
{
//Gera os Value Objects
var cpf = new CPF(command.CpfNumero);
var emailAddress = new EmailAddress(command.EmailAddress);
//Valida propriedades que não buscam de repositório
if (!(cpf.IsValid() & emailAddress.IsValid() & command.EhMaiorDeIdade()))
{
return(new ClienteCommandResult());
}
//Valida propriedades que buscam de repositório
if (!(command.PossuiCpfUnico(_clienteRepository) & command.PossuiEmailUnico(_clienteRepository)))
{
return(new ClienteCommandResult());
}
//Gera a entidade cliente
var cliente = new Cliente(command.ClienteId, command.Nome, emailAddress, cpf, command.DataNascimento, command.Ativo);
//Atualiza a entidade junto ao repositório
_clienteRepository.Atualizar(cliente);
return(new ClienteCommandResult());
}
public AtualizarClienteEvent Atualizar(AtualizarClienteViewModel viewModel)
{
var cliente = _repository.ObterPorId(viewModel.Id);
if (cliente == null)
{
return(new AtualizarClienteEvent(TipoDeMensagem.Falha, "CLIENTE NÃO ENCONTRADO"));
}
if (!viewModel.IdContato.HasValue && !viewModel.IdEndereco.HasValue)
{
return(new AtualizarClienteEvent(TipoDeMensagem.Falha, "Não foi informado dados para atualização"));
}
if (viewModel.IdContato.HasValue)
{
cliente.AlterarContato(viewModel.IdContato.Value);
}
if (viewModel.IdEndereco.HasValue)
{
cliente.AlterarEndereco(viewModel.IdEndereco.Value);
}
_repository.Atualizar(cliente);
return(new AtualizarClienteEvent(TipoDeMensagem.Sucesso, "Cliente atualizado com sucesso"));
}
public IResultViewModel AtualizarCliente(AtualizarClienteViewModel model)
{
var clienteModel = new Cliente(model.Nome, model.Cpf, model.DataNascimento);
clienteModel.Validate();
if (clienteModel.Invalid)
{
return new ResultViewModel {
Success = false, Message = "Ocorreu um problema ao atualizar o cliente.", Data = clienteModel.Notifications
}
}
;
var cliente = _repository.ListarPorId(model.Id);
cliente.UpdateNome(clienteModel.Nome);
cliente.UpdateCPF(clienteModel.Cpf);
cliente.UpdateDataNascimento(clienteModel.DataNascimento);
_repository.Atualizar(cliente);
return(new ResultViewModel {
Success = true, Message = "Cliente atualizado.", Data = cliente
});
}
public async Task <Response> AtualizarAsync(long id, ClienteDto dto)
{
try
{
var cliente = ClienteMapper.MapearDtoParaModelo(dto);
if (!cliente.EValido())
{
return(CriarResposta(UNPROCESSABLE_ENTITY, false, cliente.GetMensagemValidacao()));
}
if (await _clienteRepository.ObterAsync(id) == null)
{
return(CriarResposta(UNPROCESSABLE_ENTITY, false, "Cliente inexistente."));
}
await _clienteRepository.Atualizar(id, cliente);
return(CriarResposta(OK, true, "Cliente atualizado."));
}
catch (System.Exception e)
{
return(CriarResposta(INTERNAL_SERVER_ERROR, false, "Ocorreu um erro ao tentar atualizar o cliente. Favor aguardar uns minutos e tentar novamente."));
}
}
public void Atualizar(ClienteViewModel model)
{
var cliente = _clienteRepository.GetById(model.ClienteId);
if (cliente == null)
{
_clienteRepository.Salvar(new Cliente()
{
NomeCliente = model.NomeCliente,
Apelido = model.Apelido,
DocumentoCliente = model.DocumentoCliente,
Sexo = model.Sexo,
EstadoCivil = model.EstadoCivil,
DataNascimento = model.DataNascimento,
Email = model.Email,
TelefoneFixo = model.TelefoneFixo,
TelefoneCelular = model.TelefoneCelular,
TelefoneOutros = model.TelefoneOutros,
LogradouroCEP = model.LogradouroCEP,
LogradouroNome = model.LogradouroNome,
LogradouroNumero = model.LogradouroNumero,
LogradouroComplemento = model.LogradouroComplemento,
LogradouroMunicipio = model.LogradouroMunicipio,
LogradouroBairro = model.LogradouroBairro,
LogradouroUF = model.LogradouroUF,
RecebeNotificacoes = model.RecebeNotificacoes,
ClienteAtivo = true,
DataCadastro = DateTime.Now,
DataAlteracao = null
});
}
else
{
_clienteRepository.Atualizar(new Cliente()
{
ClienteId = cliente.ClienteId,
NomeCliente = model.NomeCliente,
Apelido = model.Apelido,
DocumentoCliente = model.DocumentoCliente,
Sexo = model.Sexo,
EstadoCivil = model.EstadoCivil,
DataNascimento = model.DataNascimento,
Email = model.Email,
TelefoneFixo = model.TelefoneFixo,
TelefoneCelular = model.TelefoneCelular,
TelefoneOutros = model.TelefoneOutros,
LogradouroCEP = model.LogradouroCEP,
LogradouroNome = model.LogradouroNome,
LogradouroNumero = model.LogradouroNumero,
LogradouroComplemento = model.LogradouroComplemento,
LogradouroMunicipio = model.LogradouroMunicipio,
LogradouroBairro = model.LogradouroBairro,
LogradouroUF = model.LogradouroUF,
RecebeNotificacoes = model.RecebeNotificacoes,
ClienteAtivo = model.ClienteAtivo,
DataAlteracao = DateTime.Now
});
}
}
public IActionResult Atualizar(Models.Cliente cliente)
{
ModelState.Remove("Senha");
ModelState.Remove("ConfirmacaoSenha");
if (ModelState.IsValid)
{
cliente.Senha = _loginCliente.GetCliente().Senha;
_clienteRepository.Atualizar(cliente);
_loginCliente.Login(cliente);
TempData["MSG_S"] = Mensagem.MSG_S001;
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public Cliente Atualizar(Cliente cliente)
{
if (!cliente.IsValid())
{
return(cliente);
}
return(_clienteRepository.Atualizar(cliente, cliente.ClienteId));
}
public Cliente Atualizar(Cliente Cliente)
{
if (!Cliente.IsValid())
{
return(Cliente);
}
return(!Cliente.ValidationResult.IsValid ? Cliente : _ClienteRepository.Atualizar(Cliente));
}
public Cliente Atualizar(Cliente cliente)
{
if (!PossuiConformidade(new ClienteAptaParaEdicaoValidation(_clienteRepository).Validate(cliente)))
{
_clienteRepository.Atualizar(cliente);
}
return(cliente);
}
public Cliente Atualizar(Cliente cliente)
{
if (!cliente.EhValido())
{
return(cliente);
}
return(_clienteRepository.Atualizar(cliente));
}
public IActionResult AtivarDesativar(int id)
{
Cliente cliente = _clienteRepository.ObterCliente(id);
cliente.Situacao = (cliente.Situacao == SituacaoConstant.Ativo) ? cliente.Situacao = SituacaoConstant.Desativado : cliente.Situacao = SituacaoConstant.Ativo;
_clienteRepository.Atualizar(cliente);
TempData["MSG_S"] = Mensagem.MSG_S002;
return(RedirectToAction(nameof(Index)));
}
public async Task Atualizar(Cliente entity)
{
//Validar
if (!ExecutarValidacao(new ClienteValidation(), entity))
{
return;
}
//Executar
await _clienteRepository.Atualizar(entity);
}
public async Task Atualizar(Cliente cliente)
{
if (!ClienteValido(cliente))
{
return;
}
var validation = new ClienteAptoParaAtualizarValidation(cliente, _clienteRepository).Validate(cliente);
if (!validation.IsValid)
{
NotificarValidacoesErro(validation);
return;
}
await _clienteRepository.Atualizar(cliente);
await _mediator.RaiseEvent(ClienteAdapter.ToClienteAtualizadoEvent(cliente));
}
public IActionResult AtivarDesativar(int id)
{
var cliente = _clienteRepository.Obter(id);
cliente.Situacao = cliente.Situacao == SituacaoConstante.Ativo ? SituacaoConstante.Desativado : SituacaoConstante.Ativo;
_clienteRepository.Atualizar(cliente);
TempData["MSG_SUCESSO"] = Mensagem.MSG_SUCESSO_ATUALIZADO;
return(RedirectToAction(nameof(Index)));
}
public Cliente Atualizar(Cliente cliente)
{
if (!cliente.EhValido())
{
return(cliente);
}
//cliente.ValidationResult = new ClienteAptoParaCadastroValidation(_clienteRepository).Validate(cliente);
return(!cliente.ValidationResult.IsValid?cliente:_clienteRepository.Atualizar(cliente));
}
public async Task <bool> Atualizar(Cliente cliente)
{
if (!ExecutarValidacao(new ClienteValidation(), cliente))
{
return(false);
}
await _clienteRepository.Atualizar(cliente);
return(true);
}
public Task <bool> Handle(AprovarClienteCommand request, CancellationToken cancellationToken)
{
var cliente = ObterClienteExistente(request.Id);
if (cliente == null)
{
return(Falha());
}
cliente.Aprovar();
if (!ValidarCliente(cliente))
{
return(Falha());
}
_clienteRepository.Atualizar(cliente);
_mediator.RaiseEvent(ClienteAdapter.ToClienteAprovadoEvent(request));
return(Sucesso());
}
