public Task<HttpResponseMessage> EditarCliente(ClienteModel model)
{
HttpResponseMessage response;
try
{
var pessoa = Mapper.Map<Pessoa>(model);
//Remove informações que não vão ser gravadas.
((List<MeioComunicacao>)pessoa.MeiosComunicacao).RemoveAll(
x => string.IsNullOrEmpty(x.MeioComunicacaoNome) && x.MeioComunicacaoCodigo.Equals(0));
if (model.EPessoaFisica)
{
pessoa.PessoaFisica = Mapper.Map<PessoaFisica>(model);
}
else
{
pessoa.PessoaJuridica = Mapper.Map<PessoaJuridica>(model);
}
_pessoaService.AtualizarPessoa(pessoa);
response = ReturnSuccess();
}
catch (Exception ex)
{
response = ReturnError(ex);
}
var tsc = new TaskCompletionSource<HttpResponseMessage>();
tsc.SetResult(response);
return tsc.Task;
}
private void newClientButton_Click(object sender, RoutedEventArgs e)
{
string Nome = this.NomeTxtBox.Text;
string Cpf = this.CpfTxtBox.Text;
string Email = this.EmailTxtBox.Text;
string Telefone = this.TelTxtBox.Text;
if (String.IsNullOrEmpty(Nome) || String.IsNullOrEmpty(Cpf) || String.IsNullOrEmpty(Email) || String.IsNullOrEmpty(Telefone) )
{
MessageBox.Show("Preencha todos os campos!");
}
else
{
ClienteModel c = new ClienteModel();
c.Nome = Nome;
c.Cpf = Convert.ToInt64(Cpf);
c.Email = Email;
c.Telefone = Telefone;
ClienteControler cCtrl = new ClienteControler();
cCtrl.saveInfo(c);
MessageBox.Show("Novo Cliente Cadastrado!");
this.NavigationService.Navigate(new ConsultaClientePage());
}
}
public void Update(ClienteModel cliente)
{
using (var context = new ClienteIndexContext())
{
context.Entry(cliente).State = EntityState.Modified;
context.SaveChanges();
}
}
public void Create(ClienteModel cliente)
{
using (var context = new ClienteIndexContext())
{
context.Clientes.Add(cliente);
context.SaveChanges();
}
}
public ActionResult Delete(ClienteModel clienteM)
{
try
{
// TODO: Add delete logic here
ClienteDb.Clientes.Remove(clienteM.Id);
return RedirectToAction("Index");
}
catch
{
return View();
}
}
public ActionResult Edit(int id, ClienteModel clienteM)
{
try
{
// TODO: Add update logic here
ClienteDb.Clientes[id] = clienteM;
return RedirectToAction("Index");
}
catch
{
return View();
}
}
private void removeClientButton_Click(object sender, RoutedEventArgs e)
{
string delCliente = delCpfTxtBox.Text;
int index = Convert.ToInt32(delCliente);
ClienteControler cTrl = new ClienteControler();
ClienteModel cliente = new ClienteModel();
cliente = cTrl.findInfo(index);
cTrl.deleteInfo(cliente);
var db = new Contexto();
this.ClientDataGrid.ItemsSource = db.Cliente.ToList();
}
public IActionResult Cadastrar(IFormCollection form)
{
ClienteModel cliente = new ClienteModel();
cliente.Nome = form["nome"];
cliente.Endereco = form["endereco"];
cliente.Telefone = form["telefone"];
cliente.Senha = form["senha"];
cliente.Email = form["email"];
cliente.DataNascimento = DateTime.Parse(form["data-nascimento"]);
clienteRepositorio.Inserir(cliente);
ViewData["Action"] = "Cadastro";
return(RedirectToAction("Index", "Home"));
}
public IActionResult Create(ClienteModel clienteModel)
{
// Compreobamos que el modelo sea valido
if (ModelState.IsValid)
{
clienteModel.Id = Guid.NewGuid().ToString();
_context.Clientes.Add(clienteModel);
_context.SaveChanges();
ViewBag.MensajeExtra = "Cliente Creado";
return(View("Index", clienteModel));
}
else
{
return(View(clienteModel));
}
}
public JsonResult Incluir(ClienteModel model)
{
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
CPFValidateReturn cpfValid = CpfValidate.ValidateCpf(model.CPF);
if (!cpfValid.IsValid)
{
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, cpfValid.Message)));
}
BoCliente bo = new BoCliente();
if (bo.VerificarExistencia(model.CPF))
{
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, "Esse CPF já está cadastrado!")));
}
model.Id = bo.Incluir(new Cliente()
{
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone,
CPF = model.CPF
});
return(Json("Cadastro efetuado com sucesso"));
}
}
/// <summary>
///
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public bool Add(ClienteModel model)
{
#region Regras
model.DataCadastro = DateTime.Now;
model.Ativo = true;
model.ClienteTelefone.ToList().ForEach(t =>
{
t.DataCadastro = DateTime.Now;
t.Ativo = true;
if (string.IsNullOrEmpty(t.Ddd) && string.IsNullOrEmpty(t.TipoTelefone) &&
string.IsNullOrEmpty(t.Telefone))
{
model.ClienteTelefone.Remove(t);
}
});
model.ClienteEndereco.ToList().ForEach(t =>
{
t.DataCadastro = DateTime.Now;
t.Ativo = true;
});
var contatos = new List <ClienteContatoModel>();
if (model.ContatoNome != null)
{
for (int i = 0; i < model.ContatoNome.Length; i++)
{
if (!string.IsNullOrEmpty(model.ContatoNome[i]) && !string.IsNullOrEmpty(model.ContatoEmail[i]))
{
ClienteContatoModel c = new ClienteContatoModel
{
Nome = model.ContatoNome[i],
Email = model.ContatoEmail[i],
Ativo = true,
DataCadastro = DateTime.Now
};
contatos.Add(c);
}
}
}
model.ClienteContato = contatos;
/*to do: model.UsuarioIdCriCliente = ?*/
#endregion
return(_rep.Add(model));
}
public JsonResult Incluir(ClienteModel model)
{
BoCliente bo = new BoCliente();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
FI.AtividadeEntrevista.BLL.BoCliente clienteBLL = new BoCliente();
if (!clienteBLL.VerificarExistencia(model.CPF))
{
try
{
model.Id = bo.Incluir(new Cliente()
{
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone,
CPF = model.CPF
});
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
}
}
else
{
return(Json("CPF já existe."));
}
return(Json("Cadastro efetuado com sucesso"));
}
}
public async Task <IActionResult> UpdateCliente(ClienteModel cliente)
{
// Repensar em como fazer aqui
if (!ModelState.IsValid)
{
throw new Exception("Propriedades Inválidas");
}
if (!Validators.ValidarCPF(cliente.Cliente_CPF))
{
throw new Exception("CPF INVÁLIDO");
}
await _clienteService.UpdateClientesAsync(cliente);
return(RedirectToAction("Index"));
}
/// <summary>
///
/// </summary>
/// <param name="value"></param>
// POST: api/Cliente
public void Post(ClienteModel model)
{
int IdCliente;
if (model.IdCliente > 0)
{
//llamar el core para actualizar
IdCliente = model.IdCliente;
core.ModifyCliente(model);
}
else
{
//llamar el core para añadir
core.AddCliente(model);
}
}
// GET: Crear Cliente
public ActionResult Crear()
{
if (Session["Key"] == null)
{
return(RedirectToAction("../Login/Index"));
}
CargarSexo();
CargarTipo();
ClienteModel client = new ClienteModel();
client.Correos.Add(new CorreoModel());
client.Telefonos.Add(new TelefonoModel());
client.Direcciones.Add(new DireccionModel());
return(View(client));
}
public async Task <string> Post([FromBody] ClienteModel model)
{
try
{
await _clienteAppService.Adicionar(model);
}
catch (DominioException ex)
{
return(ex.Message);
}
catch (Exception ex)
{
return(ex.Message);
}
return(null);
}
public IActionResult Cadastrar(IFormCollection form)
{
ClienteModel cliente = new ClienteModel(
nome: form["nome"],
cpf: form["CPF"],
dataNascimento: DateTime.Parse(form["dataNascimento"]),
cargo: form["cargo"],
endereco: form["endereco"],
email: form["email"],
telefone: form["telefone"],
senha: form["senha"]
);
ClienteRepositorio.Inserir(cliente);
return(RedirectToAction("Index", "Cliente"));
}//fim Cadastrar
public IEnumerable <ClienteModel> GetAll()
{
lock (_Locker)
{
lock (_Locker)
{
string SQL = $"SELECT * FROM CLIENTE";
var database = Factory.DatabaseFactory.BuildDatabase();
var currentConnection = database.GetCurrentConnection();
List <ClienteModel> result = new List <ClienteModel>();
try
{
var command = currentConnection.CreateCommand();
command.CommandText = SQL;
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var cliente = new ClienteModel();
cliente.Codigo = reader.GetInt32(0);
cliente.CNPJ = reader.GetString(1);
cliente.Nome = reader.GetString(2);
result.Add(cliente);
}
}
currentConnection.Close();
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (currentConnection.State == System.Data.ConnectionState.Open)
{
currentConnection.Close();
}
}
return(result);
}
}
}
// GET: /Cliente/Details/5
public ActionResult Details(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Mapper.CreateMap <Cliente, ClienteModel>();
ClienteModel clientemodel = Mapper.Map <Cliente, ClienteModel>(db.Clientes.Find(id));
if (clientemodel == null)
{
return(HttpNotFound());
}
return(View(clientemodel));
}
public List <ClienteModel> Listar()
{
Cmd.Connection = Conexao.RetornarConexao();
Cmd.CommandText = "SELECT * FROM Cliente";
SqlDataReader rd = Cmd.ExecuteReader();
List <ClienteModel> clientes = new List <ClienteModel>();
while (rd.Read())
{
ClienteModel cliente = new ClienteModel((int)rd["Id"], (string)rd["Nome"], (string)rd["CPF"], (string)rd["Email"],
(DateTime)rd["DataNascimento"], (bool)rd["Ativo"], (string)rd["Sexo"], (string)rd["EstadoCivil"], (byte[])rd["Imagem"]);
clientes.Add(cliente);
}
rd.Close();
return(clientes);
}
public ReturnAllServices RegistrarCliente([FromBody] ClienteModel dados)
{
ReturnAllServices retorno = new ReturnAllServices();
try
{
dados.RegistrarCliente();
retorno.Result = true;
retorno.ErrorMessage = string.Empty;
}
catch (Exception e)
{
retorno.Result = false;
retorno.ErrorMessage = "Erro ao tentar registrar um cliente: " + e.Message;
}
return(retorno);
}
public ActionResult EditarClientes(ClienteModel model)
{
_token = Session["Token"].ToString();
var cliente = new Clientes
{
Token = _token,
correo = model.Correo,
dv = model.Dv,
nombre = model.Nombre,
apellido = model.Apellido,
rut = model.Rut,
telefono = model.Telefono,
};
cliente.ActualizarClientes(cliente);
return(RedirectToAction("VerClientes"));
}
public ActionResult Create(ClienteModel clienteM)
{
try
{
if (ClienteDb.Clientes.Count == 0)
clienteM.Id = 1;
else
clienteM.Id = ClienteDb.Clientes[ClienteDb.Clientes.Count() - 1].Id + 1;
ClienteDb.Clientes.Add(clienteM.Id, clienteM);
return RedirectToAction("Index");
}
catch
{
return View();
}
}
public ClienteModel Save(ClienteModel model)
{
var cliente = _db.Cliente.AsNoTracking().FirstOrDefault(x => x.PersonaId == model.PersonaId);
if (cliente == null)
{
_db.Cliente.Add(model.ClienteFactory());
}
else
{
_db.Entry(model.ClienteFactory()).State = EntityState.Modified;
}
_db.SaveChanges();
return(model);
}
public IHttpActionResult PayEdit(MetodoPagoModel metodoPago)
{
if (usuario.id == 0)
{
throw new ArgumentException(Constants.NO_AUTH);
}
if (metodoPago.ClienteMetodoDePagos == null)
{
return(Json(Mensaje <Domain.Entities.Cliente.ClienteMetodoDePago> .MensajeJson(Constants.IS_ERROR, "Objecto no puede estar vacio", Constants.PAY_FAIL)));
}
try
{
int cont = 0;
var cliente = ClienteModel.GetAll(usuario.id).Cliente;
metodoPago.ClienteMetodoDePagos.ToList().ForEach(x =>
{
var response = metodoPago.ServicioMetodoPago.Edit(new ServicioMetodoPagoRequest
{
Activo = x.Activo,
Cliente_Id = cliente.Id,
Saldo = x.Saldo,
CreditCard = x.CreditCard,
Id = x.Id,
Cliente = cliente
});
if (response.Status)
{
cont++;
}
});
if (cont == 0)
{
return(Json(Mensaje <Domain.Entities.Cliente.ClienteMetodoDePago> .MensajeJson(Constants.IS_ERROR, "Error, No se pudo modificar, ", Constants.PAY_FAIL)));
}
return(Json(Mensaje <Domain.Entities.Cliente.ClienteMetodoDePago> .MensajeJson(Constants.NO_ERROR, "Se Modificaron " + cont + " Metodos de pago", Constants.PAY_SUCCESS)));
}
catch (Exception e)
{
return(Json(Mensaje <Domain.Entities.Cliente.ClienteMetodoDePago> .MensajeJson(Constants.NO_ERROR, e.Message, Constants.PAY_FAIL)));
}
}
public JsonResult Incluir(ClienteModel model)
{
BoCliente bo = new BoCliente();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
var cpf = Regex.Replace(model.CPF, "[^0-9a-zA-Z]+", "");
if (bo.VerificarExistencia(cpf))
{
return(Json("CPF já existente na base de dados!"));
}
if (!Validacao.ValidaCPF.IsValidCpf(cpf))
{
return(Json("O número do CPF é inválido!"));
}
model.Id = bo.Incluir(new Cliente()
{
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone,
CPF = cpf
});
return(Json("Cadastro efetuado com sucesso"));
}
}
public JsonResult Alterar(ClienteModel model)
{
BoCliente bo = new BoCliente();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
if (!Validacoes.ValidarCPF(model.CPF))
{
return(Json("CPF não é válido"));
}
model.CPF = model.CPF.Trim().Replace(".", "").Replace("-", "");
if (!bo.VerificarExistencia(model.CPF))
{
return(Json("Este CPF já foi cadastrado"));
}
else
{
bo.Alterar(new Cliente()
{
Id = model.Id,
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone,
CPF = model.CPF.Trim().Replace(".", "").Replace("-", "")
});
return(Json("Cadastro alterado com sucesso"));
}
}
public JsonResult Incluir(ClienteModel model)
{
BoCliente bo = new BoCliente();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
var objToAdd = new Cliente()
{
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone,
Cpf = model.Cpf
};
var validador = clienteValidator.Validate(objToAdd);
if (!validador.IsValid)
{
return(Json(string.Join(Environment.NewLine, validador.Errors)));
}
if (bo.VerificarExistencia(model.Cpf))
{
Response.StatusCode = 400;
return(Json("CPF já Existente!"));
}
model.Id = bo.Incluir(objToAdd);
return(Json("Cadastro efetuado com sucesso"));
}
public JsonResult Alterar(ClienteModel model)
{
BoCliente bo = new BoCliente();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
var cliente = new Cliente()
{
Id = model.Id,
CEP = model.CEP,
CPF = model.CPF,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone
};
model.Beneficiarios.ForEach(b => cliente.Beneficiarios.Add(new Beneficiario()
{
CPF = b.CPF,
Nome = b.Nome,
Cliente = new Cliente()
{
Id = model.Id
}
}));
bo.Alterar(cliente);
return(Json("Cadastro alterado com sucesso"));
}
}
public JsonResult Incluir(ClienteModel model)
{
BoCliente bo = new BoCliente();
var mensagemValidacao = "CPF inválido. Consulte o Admin do Sistema.";
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
if (bo.VerificarExistencia(model.CPF))
{
return(Json("CPF já cadastrado no banco de dados. Admin."));
}
IValidacao validador = new Validacao();
if (!validador.ValidarCPF(model.CPF))
{
return(Json(mensagemValidacao));
}
model.Id = bo.Incluir(new Cliente()
{
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone,
CPF = model.CPF
});
return(Json("Cadastro efetuado com sucesso"));
}
}
public JsonResult Incluir(ClienteModel model)
{
BoCliente bo = new BoCliente();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
try
{
model.Id = bo.Incluir(new Cliente()
{
CEP = model.CEP,
CPF = model.CPF,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone
});
}catch (SqlException ex)
{
if (ex.Number == 2627 || ex.Number == 2601) // <-- but this will
{
return(Json(model.CPF + " já foi cadastrado"));
}
else
{
return(Json(ex.Message));
}
}
return(Json("Cadastro efetuado com sucesso"));
}
}
public JsonResult Incluir(ClienteModel model)
{
BoCliente bo = new BoCliente();
BoBeneficiario boBeneficiario = new BoBeneficiario();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join("<br/>", erros)));
}
else if (bo.VerificarExistencia(model.CPF))
{
Response.StatusCode = 400;
return(Json(string.Concat(Environment.NewLine, "CPF Ja Cadastrado")));
}
else
{
model.Id = bo.Incluir(new Cliente()
{
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
Telefone = model.Telefone,
CPF = model.CPF
});
var feed = boBeneficiario.Incluir(model.Beneficiarios.Select(item => new Beneficiario
{
Nome = item.Nome,
CPF = item.CPF,
ClientId = model.Id
}).ToList());
return(Json("Cadastro efetuado com sucesso"));
}
}
public JsonResult Alterar(ClienteModel model)
{
BoCliente bo = new BoCliente();
if (!this.ModelState.IsValid)
{
List <string> erros = (from item in ModelState.Values
from error in item.Errors
select error.ErrorMessage).ToList();
Response.StatusCode = 400;
return(Json(string.Join(Environment.NewLine, erros)));
}
else
{
//Remover os caracteres não numéricos
string cpfCompleto = model.CPF;
string cpfBasico = cpfCompleto.Replace(".", "").Replace("-", "");
bool cpfCadastrado = bo.VerificarExistencia(cpfBasico);
if (!cpfCadastrado)
{
bo.Alterar(new Cliente()
{
Id = model.Id,
CEP = model.CEP,
Cidade = model.Cidade,
Email = model.Email,
Estado = model.Estado,
Logradouro = model.Logradouro,
Nacionalidade = model.Nacionalidade,
Nome = model.Nome,
Sobrenome = model.Sobrenome,
CPF = cpfBasico,
Telefone = model.Telefone
});
}
else
{
return(Json("CPF já cadastrado!"));
}
return(Json("Cadastro alterado com sucesso"));
}
}
protected void AtualizarClienteCookie(ClienteModel cliente)
{
var cookieValue = Request.Cookies[_chaveCookieAuth];
if (!String.IsNullOrWhiteSpace(cookieValue))
{
var autenticacao = JsonSerializer.Deserialize <AutenticacaoModel>(cookieValue);
if (autenticacao != null)
{
autenticacao.Cliente = cliente;
CookieOptions cookieOptions = new CookieOptions();
cookieOptions.Expires = DateTime.Now.AddMinutes(30);
string value = JsonSerializer.Serialize <AutenticacaoModel>(autenticacao);
Response.Cookies.Append(_chaveCookieAuth, value, cookieOptions);
}
}
}
public ReturnAllServices Atualizar(int id, [FromBody] ClienteModel dados)
{
ReturnAllServices retorno = new ReturnAllServices();
try
{
dados.Id = id;
dados.AtualizarCliente();
retorno.Result = true;
retorno.ErrorMessage = string.Empty;
}
catch (Exception ex)
{
retorno.Result = false;
retorno.ErrorMessage = "Erro ao Atualizar Cliente:" + ex.Message;
}
return(retorno);
}
public void Save(ClienteModel Clientes)
{
using (var db = new INOVECREntities())
{
if (Clientes.ClienteId == 0)
{
db.Clientes.Add(ClientesFactory.ToEntity(Clientes));
}
else
{
var registro = db.Clientes.Single(x => x.ClienteId == Clientes.ClienteId);
ClientesFactory.ToEntity(Clientes, registro);
}
db.SaveChanges();
}
}
public ReturnAllServices Atualizar([FromBody] ClienteModel dados)
{
ReturnAllServices returnAll = new ReturnAllServices();
try
{
dados.AtualizarCliente();
returnAll.Result = true;
returnAll.ErrorMessage = string.Empty;
}
catch (Exception ex)
{
returnAll.Result = false;
returnAll.ErrorMessage = "Erro ao tentar registrar um cliente: " + ex.Message;
}
return(returnAll);
}
// GET: Cliente/Details/5
public ActionResult Details(long id)
{
ClienteModel Cliente = null;
RestClient restClient = new RestClient(ConfigurationManager.AppSettings["URLBackend"] + "api/Cliente/" + id);
RestRequest request = new RestRequest(Method.GET);
request.AddHeader("Content-Type", "application/json");
var response = restClient.Execute(request);
if (response.StatusCode == HttpStatusCode.OK)
{
var resp = response.Content;
resp = resp.Trim("\"".ToCharArray());
resp = resp.Replace("\\", "");
Cliente = new List <ClienteModel>(JsonConvert.DeserializeObject <List <ClienteModel> >(resp)).FirstOrDefault();
}
return(View(Cliente));
}
public List<ClienteModel> query(ClienteModel cliente)
{
List<ClienteModel> listaCombinada = null;
try
{
using (var db = new Contexto())
{
var todosClientes = db.Cliente.ToList();
List<ClienteModel> listaNome= todosClientes;
List<ClienteModel> listaCpf = todosClientes;
List<ClienteModel> listaEmail = todosClientes;
List<ClienteModel> listaTefone = todosClientes;
if (cliente.Nome != "")
{
listaNome = db.Cliente.Where(d => (d.Nome.Contains(cliente.Nome))).ToList();
}
if (cliente.Cpf != -1)
{
listaCpf = db.Cliente.Where(d => (d.Cpf.Equals(cliente.Cpf))).ToList();
}
if (cliente.Email != "")
{
listaEmail = db.Cliente.Where(d => (d.Email.Equals(cliente.Email))).ToList();
}
if (cliente.Telefone != "")
{
listaTefone = db.Cliente.Where(d => (d.Telefone.Equals(cliente.Telefone))).ToList();
}
listaCombinada = listaNome.Intersect(listaCpf).Intersect(listaEmail).Intersect(listaTefone).ToList();
}
}
catch (Exception e)
{
throw e;
}
return listaCombinada;
}
public void deleteInfo(ClienteModel c)
{
ClienteModel cliente = new ClienteModel();
cliente = c;
try
{
using (var db = new Contexto())
{
var entry = db.Entry(cliente);
if (entry.State == EntityState.Detached)
db.Cliente.Attach(cliente);
db.Cliente.Remove(cliente);
db.SaveChanges();
}
}
catch
{
MessageBox.Show("Erro na remoção");
}
}
//public ClienteModel findInfo(string cpf)
public ClienteModel findInfo(int index)
{
ClienteModel cliente = new ClienteModel();
ClienteModel c1 = new ClienteModel();
//cliente.Cpf = Convert.ToInt64(cpf);
try
{
using (var db = new Contexto())
{
c1 = db.Cliente.Find(index);
return c1;
}
}
catch
{
MessageBox.Show("Erro na remoção");
return c1;
}
}
private void pesquisarClientButton_Click(object sender, RoutedEventArgs e)
{
string Nome = NameTxtBox.Text;
string Cpf = CpfTxtBox.Text;
string Email = EmailTxtBox.Text;
string Telefone = TelTxtBox.Text;
ClienteModel c = new ClienteModel();
////chamar a query com todos esses campos
//var db = new Contexto();
//this.ClientDataGrid.ItemsSource = query(Nome, Cpf, Email, Telefone);
c.Nome = Nome;
c.Telefone = Telefone;
c.Email = Email;
if (Cpf != "")
c.Cpf = Convert.ToInt64(Cpf);
else
c.Cpf = -1;
ClienteControler lCtrl = new ClienteControler();
List<ClienteModel> listCliente = lCtrl.query(c);
var db = new Contexto();
this.ClientDataGrid.ItemsSource = listCliente;
}
public JsonResult NovoCliente(ClienteModel model)
{
model.PapelPessoa = (int)TipoPapelPessoaEnum.Cliente;
var response = ServiceRequest.Post<RetornoBase<object>>(model, "api/Cliente/CriarCliente");
return ReturnResponse(response);
}
public JsonResult EditarCliente(ClienteModel model)
{
var response = ServiceRequest.Put<RetornoBase<object>>(model, "api/Cliente/EditarCliente");
return ReturnResponse(response);
}
/* Tá dando erro pra testar D: Vou comentar por enquanto */
public void saveInfo(ClienteModel c)
{
ClienteModel cliente = new ClienteModel();
cliente.Cpf = c.Cpf;
cliente.Email = c.Email;
cliente.Nome = c.Nome;
cliente.Telefone = c.Telefone;
try
{
using (var db = new Contexto())
{
db.Cliente.Add(cliente);
db.SaveChanges();
}
}
catch {
Console.WriteLine("Erro na inserção");
}
}
public void updateInfo(ClienteModel c)
{
ClienteModel cliente = new ClienteModel();
//+= String.Format(" (userUsername LIKE @{0} OR userName LIKE @{0} OR userSurname LIKE @{0}) OR ", id);
}
