public async Task RegistrarAsync(Guid Id, string nome, string email, string celular, string cpf, DateTime dataNascimento, string cep)
{
var cliente = new Cliente()
{
Id = Id,
Nome = nome,
Email = email,
Celular = celular,
Cpf = cpf,
DataNascimento = dataNascimento,
Cep = cep
};
var ValidationResult = new RegisterNewClienteValidation().Validate(cliente);
if (!ValidationResult.IsValid)
{
NotificarValidacoesErro(ValidationResult);
return;
}
var location = await _locationAppService.GetLocation(cliente.Cep);
cliente.Latitude = location.lat;
cliente.Longitude = location.lng;
cliente.CurtaDescricao = "Olá, meu nome é " + cliente.Nome;
cliente.LongaDescricao = "Olá, meu nome é " + cliente.Nome;
// TODO:
// Validacoes de negocio!
cliente.Preferencia = new Preferencia()
{
Distancia = 150,
IdadeMaxima = 65,
IdadeMinima = 18,
PrecoMinimo = 0,
PrecoMaximo = 5000
};
cliente.Caracteristica = new Caracteristica()
{
LocalProprio = false,
Valor1Hora = 0,
Valor2horas = 0,
Valor30min = 0,
ValorPernoite = 0
};
_clienteRepository.Add(cliente);
await _clienteRepository.SaveChangesAsync();
}
public async Task AdicionarNovoCliente(Cliente cliente)
{
await _clienteRepository.Add(cliente);
await Clients.Group(groupId)
.SendAsync("TheosSignalR", await _clienteRepository.GetClientes());
}
public ActionResult AddEdit(Cliente model)
{
if (ModelState.IsValid)
{
try
{
if (model.Id == 0)
{
_clienteRepo.Add(model);
}
else
{
_clienteRepo.Update(model);
}
//throw new Exception("Erro no banco");
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
}
return(View(model));
}
async Task <int> IPedidoService.Incluir(Pedido pedido)
{
bool pedidoValido = pedido.PedidoValido();
if (!pedidoValido)
{
return(-1);
}
IEnumerable <int> IdsPizzas = pedido.Pizzas.Select(x => x.IdPizzaSabor1).Union(pedido.Pizzas.Where(x => x.IdPizzaSabor2 != null).Select(x => x.IdPizzaSabor2.Value));
ICollection <PizzaSabores> pizzas = await GetPizzas(IdsPizzas);
if (pizzas.Count != IdsPizzas.Count())
{
return(-2); // Id de pizza inexistente
}
bool clienteExiste = await _clienteRepository.ClienteExiste(pedido.IdCliente);
if (!clienteExiste)
{
Cliente newCliente = new Cliente(pedido.Endereco_Entrega);
Cliente cliente = await _clienteRepository.Add(newCliente);
pedido.SetCliente(cliente.Id);
}
pedido.CalcularValorTotal(pizzas);
pedido.Criar();
Pedido result = await _pedidoRepository.Add(pedido);
return(result.Id);
}
public void Adicionar()
{
var cliente = new Domain.Entity.Clientes()
{
Id = Guid.NewGuid(),
Nome = "Núbia",
CPF = "07986401621",
DataCadastro = DateTime.Now,
DataNascimento = DateTime.Now,
Email = "*****@*****.**",
Endereco = new Domain.Entity.Endereco
{
Bairro = "Sao Mateus",
CEP = "36680000",
Cidade = "Juiz de Fora",
Complemento = "nao tem",
Estado = "MG",
Logradouro = "Rua engenheiro bicalho",
Numero = "25",
}
};
_repository.Add(cliente);
_unitOfWork.Commit();
}
public int Add(ClienteRegisterCommand clienteCmd)
{
var cliente = Mapper.Map <ClienteRegisterCommand, Cliente>(clienteCmd);
var novoCliente = _repository.Add(cliente);
return(novoCliente.Id);
}
public CrearClienteResponse Ejecutar(CrearClienteRequest request)
{
Cliente cliente = _clienteRepository.FindBy(t => t.Activo.Equals(true) && t.Correo.Equals(request.Correo)).FirstOrDefault();
if (cliente == null)
{
Cliente clientenuevo = new Cliente();//Debe ir un factory que determine el cliente que se va a crear
clientenuevo.Nombres = request.Nombres;
clientenuevo.Apellidos = request.Apellidos;
clientenuevo.Correo = request.Correo;
clientenuevo.Direccion = request.Direccion;
clientenuevo.Activo = request.Activo;
clientenuevo.FechaNacimiento = request.FechaNacimiento;
clientenuevo.FechaRegistro = request.FechaRegistro;
_clienteRepository.Add(clientenuevo);
_unitOfWork.Commit();
return(new CrearClienteResponse()
{
Mensaje = $"Se creo con exito el cliente {clientenuevo.Nombres + '-' + clientenuevo.Apellidos }."
});
}
else
{
return(new CrearClienteResponse()
{
Mensaje = $"El cliente ya existe"
});
}
}
public Response Add(ClienteDto clienteDto)
{
#region Validation
if (clienteDto.IsNotValid())
{
return(Response.BuildBadRequest(ExceptionMessages.ObjetoInvalido));
}
if (!clienteDto.CpfValid())
{
return(Response.BuildBadRequest(ExceptionMessages.CpfInvalido));
}
if (_clienteRepository.Any(CpfValidation.Limpa(clienteDto.Cpf)))
{
return(Response.BuildBadRequest(ExceptionMessages.CpfJaCadastrado));
}
#endregion
var cliente = _clienteRepository
.Add(_mapper.Map <Cliente>(clienteDto));
if (!_unitOfWork.Commit())
{
throw new ExceptionHttp(ExceptionMessages.ErroAoSalvarDados);
}
return(Response.BuildSuccess(_mapper.Map <ClienteDto>(cliente)));
}
public ActionResult <Cliente> Create(Cliente cliente)
{
try
{
if (_clienteRepository.ClienteExiste(cliente.Documento))
{
throw new Exception("Cliente já cadastrado na base de dados");
}
if (!_clienteRepository.Add(cliente))
{
throw new Exception("Ocorreu um erro ao criar o cliente");
}
return(CreatedAtAction(
nameof(Get),
new { id = cliente.Id },
cliente));
}
catch (Exception ex)
{
return(BadRequest(
new
{
Mensagem = ex.Message
}));
}
}
public async Task <IActionResult> Post([FromBody] ClienteVM model)
{
if (ModelState.IsValid)
{
if (!CpfService.IsCpf(model.Cpf))
{
return(BadRequest("CPF inválido"));
}
if (!EstadoService.IsValid(model.Estado))
{
return(BadRequest("Estado inválido"));
}
var cl = await _clienteRepository.GetByCpfAsync(model.Cpf.Trim().Replace(".", "").Replace("-", ""));
if (cl != null)
{
return(BadRequest("Cliente já cadastrado"));
}
var cliente = new Cliente()
{
Nome = model.Nome,
Estado = model.Estado,
Cpf = model.Cpf.Trim().Replace(".", "").Replace("-", "")
};
_clienteRepository.Add(cliente);
return(Ok(cliente));
}
return(BadRequest(ModelState));
}
public Task <bool> Handle(RegisterNewClienteCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var cliente = new Cliente(Guid.NewGuid(), message.Nome, message.Email, message.DataNascimento);
if (_clienteRepository.GetByEmail(cliente.Email) != null)
{
Bus.RaiseEvent(new DomainNotification(message.MessageType, "O email do cliente já foi recebido. "));
return(Task.FromResult(false));
}
_clienteRepository.Add(cliente);
if (Commit())
{
Bus.RaiseEvent(new ClienteRegisteredEvent(cliente.Id, cliente.Nome, cliente.Email, cliente.DataNascimento));
}
return(Task.FromResult(true));
}
public async Task <IncluirClienteResult> Execute(IncluirClienteParameter parameter)
{
var cliente = new Domain.Entities.Cliente(parameter.Nome, parameter.RG, parameter.CPF, parameter.Email, parameter.Endereco);
await _clienteRepository.Add(cliente);
return(new IncluirClienteResult());
}
public void Should_Register_Cliente()
{
Cliente newCliente = new Cliente("Rua Tal");
Cliente clienteRegistrado = _clienteRepository.Add(newCliente).Result;
Assert.IsTrue(clienteRegistrado.Id > 0);
}
public IActionResult Create([FromBody] Cliente cliente)
{
if (cliente == null)
{
return(BadRequest());
}
_clienteRepositorio.Add(cliente);
return(CreatedAtRoute("GetCliente", new { id = cliente.ClienteId }, cliente));
}
public void Salvar(Cliente cliente)
{
if (_clienteRepository.GetByCpf(cliente.Cpf) != null)
{
throw new ClienteException("Este Cpf já está cadastrado no banco!");
}
_clienteRepository.Add(cliente);
}
public async Task Adicionar(Cliente cliente)
{
if (!ExecutarValidacao(new ClienteValidation(), cliente))
{
return;
}
await _clienteRepository.Add(cliente);
}
public async Task <int> AddCliente(ClienteModel clienteViewmodels)
{
var addEntity = await _clienteRepository.Add(ClienteMapper.Map(clienteViewmodels));
clienteViewmodels.ticket.CliId = addEntity;
await _ticketService.Add(clienteViewmodels.ticket);
return(addEntity);
}
public IActionResult Post([FromBody] Clientes clientes)
{
var count = cliente.Add(clientes);
if (count > 0)
{
return(Ok());
}
return(BadRequest());
}
public void CreateCliente(Cliente cliente)
{
if (!ValidationHelper.ValidaCPF(cliente.CPF))
{
throw new ArgumentException("CPF inválido.");
}
clienteRepository.Add(cliente);
this.SaveCliente();
}
} //constructor
public Cliente Add(Cliente entity)
{
//Exemplo de regra de negocio sendo incluida aqui..
if (entity.Endereco.Estado != "RJ")
{
return(null);
}
return(_repository.Add(entity));
} //Add
public async Task <ActionResult> PostCliente(Cliente cliente)
{
await _clienteRepository.Add(cliente);
await _hub.Clients.Group(groupId)
.SendAsync("TheosSignalR", await _clienteRepository.GetClientes());
// await _hub.Clients.All.SendAsync("TheosSignalR", await _clienteRepository.GetClientes());
return(Ok());
}
public ActionResult Create(ClienteViewModel cliente)
{
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
_clienteApp.Add(clienteDomain);
return(RedirectToAction("Index"));
}
return(View(cliente));
}
public IActionResult Create([FromBody] tbCliente cliente)
{
if (cliente is null)
{
return(BadRequest());
}
_tbClienteRepository.Add(cliente);
return(CreatedAtRoute("GetUsuario", new { id = cliente.id_Cliente }, cliente));
}
public void Save(Cliente Cliente)
{
try
{
dbCliente.Add(Cliente);
}
catch (Exception ex)
{
throw new Exception($"Erro ao salvar Cliente: {ex.Message}.");
}
}
public ActionResult <Cliente> Cadastrar(Cliente model)
{
try
{
return(Ok(_clienteRepository.Add(model)));
}
catch (Exception e)
{
return(NotFound(e.Message));
}
}
public void Add(Cliente cliente)
{
try
{
clienteRepository.Add(cliente);
}
catch (System.Exception ex)
{
throw ex;
}
}
public void Add(Cliente myObject)
{
try
{
_repository.Add(myObject);
_unitOfWork.Commit();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void Adicionar(ClienteModel cliente)
{
cliente.Id = Guid.NewGuid();
if (!ValidCliente(cliente))
{
return;
}
_clienteRepo.Add(cliente);
Commit();
}
public void Add(ClienteModel c)
{
try
{
_clienteRepository.Add(c);
}
catch (System.Exception e)
{
_logger.LogError(e.ToString());
throw;
}
}
public void Register(ClienteViewModel ClienteViewModel)
{
var cliente = new Cliente(
new Guid(),
ClienteViewModel.Nome,
ClienteViewModel.DDD,
ClienteViewModel.Numero
);
_ClienteRepository.Add(cliente);
_ClienteRepository.SaveChanges();
}
