Beispiel #1
0
        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);
        }
Beispiel #5
0
        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();
        }
Beispiel #6
0
        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)));
        }
Beispiel #9
0
        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));
        }
Beispiel #11
0
        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));
        }
Beispiel #12
0
        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);
        }
Beispiel #14
0
 public IActionResult Create([FromBody] Cliente cliente)
 {
     if (cliente == null)
     {
         return(BadRequest());
     }
     _clienteRepositorio.Add(cliente);
     return(CreatedAtRoute("GetCliente", new { id = cliente.ClienteId }, cliente));
 }
Beispiel #15
0
        public void Salvar(Cliente cliente)
        {
            if (_clienteRepository.GetByCpf(cliente.Cpf) != null)
            {
                throw new ClienteException("Este Cpf já está cadastrado no banco!");
            }

            _clienteRepository.Add(cliente);
        }
Beispiel #16
0
        public async Task Adicionar(Cliente cliente)
        {
            if (!ExecutarValidacao(new ClienteValidation(), cliente))
            {
                return;
            }

            await _clienteRepository.Add(cliente);
        }
Beispiel #17
0
        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);
        }
Beispiel #18
0
        public IActionResult Post([FromBody] Clientes clientes)
        {
            var count = cliente.Add(clientes);

            if (count > 0)
            {
                return(Ok());
            }
            return(BadRequest());
        }
Beispiel #19
0
        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
Beispiel #21
0
        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));
        }
Beispiel #24
0
 public void Save(Cliente Cliente)
 {
     try
     {
         dbCliente.Add(Cliente);
     }
     catch (Exception ex)
     {
         throw new Exception($"Erro ao salvar Cliente: {ex.Message}.");
     }
 }
Beispiel #25
0
 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;
     }
 }
Beispiel #27
0
 public void Add(Cliente myObject)
 {
     try
     {
         _repository.Add(myObject);
         _unitOfWork.Commit();
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Beispiel #28
0
        public void Adicionar(ClienteModel cliente)
        {
            cliente.Id = Guid.NewGuid();
            if (!ValidCliente(cliente))
            {
                return;
            }

            _clienteRepo.Add(cliente);

            Commit();
        }
Beispiel #29
0
 public void Add(ClienteModel c)
 {
     try
     {
         _clienteRepository.Add(c);
     }
     catch (System.Exception e)
     {
         _logger.LogError(e.ToString());
         throw;
     }
 }
Beispiel #30
0
        public void Register(ClienteViewModel ClienteViewModel)
        {
            var cliente = new Cliente(
                new Guid(),
                ClienteViewModel.Nome,
                ClienteViewModel.DDD,
                ClienteViewModel.Numero
                );

            _ClienteRepository.Add(cliente);
            _ClienteRepository.SaveChanges();
        }