private void Btn_modificar_Click(object sender, RoutedEventArgs e)
{
if (!CumpleConCamposObligatorios())
{
MessageBox.Show("Se deben completar los campos obligatorios", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
string errorValidacion = ValidarCampos();
if (errorValidacion != null)
{
MessageBox.Show(errorValidacion, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
ClienteEntity cliente = new ClienteEntity();
cliente.Rut = tb_rut.Text;
cliente.RazonSocial = tb_razon_social.Text;
cliente.Direccion = tb_direccion.Text;
cliente.Telefono = tb_telefono.Text;
cliente.Actividad = (ActividadEmpresaEntity)cmb_actividad.SelectedItem;
cliente.Tipo = (TipoEmpresaEntity)cmb_tipo.SelectedItem;
cliente.NombreContacto = txt_nombreContacto.Text;
cliente.MailContacto = txt_emailContacto.Text;
ClienteDAO.Modificar(cliente);
MessageBox.Show("Datos de cliente actualizados");
RegistroNuevo();
}
public async Task <IActionResult> Edit(int id, [Bind("id,status_cliente,Nombre,Direccion,Email,Apellidos,Telefono")]
ClienteEntity clienteEntity)
{
if (id != clienteEntity.id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(clienteEntity);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ClienteEntityExists(clienteEntity.id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(clienteEntity));
}
private void Btn_eliminar_Click(object sender, RoutedEventArgs e)
{
ClienteEntity cliente = ClienteDAO.BuscarPorRut(tb_rut.Text);
if (cliente != null)
{
if (ContratoDAO.BuscarContratosCliente(cliente).Count != 0) // Si el cliente tiene contratos creados, no se puede eliminar (ABP 2)
{
MessageBox.Show("No se puede eliminar un cliente con contratos asociados", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
ClienteDAO.Eliminar(tb_rut.Text);
MessageBox.Show("Cliente Eliminado");
RegistroNuevo();
/*
*
* if (cliente != null)
* {
* ColeccionClientes.borrar(tb_rut.Text);
* MessageBox.Show("Cliente Eliminado");
* }
* else
* {
* MessageBox.Show("Cliente no registrado");
* }
*/
}
private bool Atualizar(ClienteEntity model)
{
model.RegistrarAlteracao();
_dbContext.Entry(model).State = EntityState.Modified;
return(_dbContext.SaveChanges() > 0);
}
public async Task <IActionResult> Vincular(int id, [Bind("id,Email,Nombre,Apellidos,Direccion,Telefono")]
ClienteEntity clienteEntity)
{
if (id != clienteEntity.id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
DistribuidorEntity distribuidor = _context.Distribuidor
.Where(d => d.Email == User.Identity.Name).FirstOrDefault();
_context.ClienteDistribuidor.Add(new ClienteDistribuidor
{
ClienteId = clienteEntity.id,
DistribuidorId = distribuidor.id,
});
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
return(RedirectToAction(nameof(Index)));
}
}
return(View(clienteEntity));
}
public bool IncluirCliente(ClienteEntity oCliente)
{
bool returnSucess = false;
returnSucess = base.IncluirCliente(oCliente);
return(returnSucess);
}
public static ClienteEntity GetIPCliente(string MAC)
{
ClienteEntity entities = new ClienteEntity();
entities = ProviderSoftv.Cablemodem.GetIPCliente(MAC);
return(entities ?? new ClienteEntity());
}
public PedidoEntity(ClienteEntity cliente, ProdutoEntity produto, int quantidade)
{
Cliente = cliente;
Produto = produto;
Quantidade = quantidade;
IdCliente = cliente.Id;
IdProduto = produto.Id;
}
public async Task <ClienteEntity> Update(ClienteEntity entity)
{
var updateEntity = _teleSoftDBContext.Clientes.Update(entity);
await _teleSoftDBContext.SaveChangesAsync();
return(updateEntity.Entity);
}
public void Eliminar(int id)
{
ClienteEntity entidad = new ClienteEntity();
entidad.IdCliente = id;
EjecutarComando(TipoComando.Eliminar, entidad);
new daUsuario().Eliminar(entidad.IdUsuario);
}
//UPDATE
public void Update(ClienteEntity c)
{
using (PetManiaDBEntities db = new PetManiaDBEntities())
{
clienteRepository.Update(db, c);
db.SaveChanges();
}
}
public bool AtualizaCliente(int idCliente, ClienteEntity cliente)
{
try
{
using (var context = new CirculoNegocioEntities())
{
tbCliente tCliente = (from p in context.tbClientes
where p.id == idCliente
select p).First();
//tCliente.anexoImagem1Path = cliente.anexoImagem1Path;
//tCliente.anexoImagem2Path = cliente.anexoImagem2Path;
//tCliente.anexoImagem3Path = cliente.anexoImagem3Path;
//tCliente.anexoLogoPath = cliente.anexoLogoPath;
tCliente.ativo = cliente.ativo;
tCliente.cep = cliente.cep;
tCliente.cidade = cliente.cidade;
tCliente.complemento = cliente.complemento;
tCliente.contatoResponsavel = cliente.contatoResponsavel;
tCliente.cpfCnpj = cliente.cpfCnpj;
tCliente.email = cliente.email;
tCliente.endereco = cliente.endereco;
tCliente.estado = cliente.estado;
tCliente.Funcionamento = cliente.Funcionamento;
tCliente.idCategoriaCliente = cliente.idCategoriaCliente;
tCliente.idSubCategoriaCliente = cliente.idSubCategoriaCliente;
tCliente.inscricaoEstadual = cliente.inscricaoEstadual;
tCliente.nome = cliente.nome;
tCliente.nomeFantasia = cliente.nomeFantasia;
tCliente.observacoes = cliente.observacoes;
tCliente.razaoSocial = cliente.razaoSocial;
tCliente.servicos = cliente.servicos;
tCliente.site = cliente.site;
tCliente.telefone1 = cliente.telefone1;
tCliente.telefone2 = cliente.telefone2;
tCliente.bairro = cliente.bairro;
tCliente.horaFdsAte = cliente.horaFdsAte;
tCliente.horaFdsDe = cliente.horaFdsDe;
tCliente.horaSemanaAte = cliente.horaSemanaAte;
tCliente.horaSemanaDe = cliente.horaSemanaDe;
tCliente.horaDomingoAte = cliente.horaDomingoAte;
tCliente.horaDomingoDe = cliente.horaDomingoDe;
tCliente.latitude = cliente.latitude;
tCliente.longitude = cliente.longitude;
context.SaveChanges();
}
return(true);
}
catch (Exception)
{
return(false);
}
}
public bool AtualidarCliente(ClienteEntity oCliente)
{
bool returnSucess = false;
returnSucess = base.AtualidarCliente(oCliente);
return(returnSucess);
}
public static Cliente Map(ClienteEntity entity)
{
return(new Cliente()
{
Id = entity.Id,
Nombre = entity.Nombre,
Correo = entity.Correo
});
}
public void Insertar(ClienteEntity entidad)
{
daContadores da = new daContadores();
entidad.IdCliente = (da.TraerContador(daComun.Contador.Cliente) + 1);
new daUsuario().Insertar(entidad);
EjecutarComando(daComun.TipoComandoEnum.Insertar, entidad);
da.Sumar(daComun.Contador.Cliente);
}
public async Task <IActionResult> ClientSideIndex()
{
ClienteEntity cliente = _context.Cliente.Where(c => c.Email == User.Identity.Name).FirstOrDefault();
return(View(await _context.ClienteDistribuidor
.Include(item => item.Distribuidor)
.Where(cd => cd.ClienteId == cliente.id)
.ToListAsync()));
}
public ClienteEntity Get(ClienteEntity criteria, bool fetchChildren = true)
{
Check.Arg.IsNotNull(() => criteria);
if (criteria.Id != null)
return repositoryManager.Get(criteria);
return null;
}
public LocacaoEntity(int id, ClienteEntity cliente, FilmeEntity filme, DateTime dataLocacao = default, DateTime dataDevolucao = default, decimal valor = default)
{
Id = id;
Cliente = cliente;
Filme = filme;
DataLocacao = dataLocacao;
DataDevolucao = dataDevolucao;
Valor = valor;
}
public List <LogradouroEntity> SelecionarLogradouroCliente(ClienteEntity myCliente, LogradouroEntity myLogradouro)
{
List <LogradouroEntity> returnLogradouroEntity = new List <LogradouroEntity>();
returnLogradouroEntity = SelecionarLogradouroPorCliente(myCliente, myLogradouro);
return(returnLogradouroEntity);
}
public IActionResult Create(int?idTalonera, int?idCliente)
{
ViewBag.idTalonera = idTalonera;
ViewBag.idCliente = idCliente;
if (idTalonera == null)
{
return(NotFound());
}
TaloneraEntity talonera = _context.Talonera
.Include(item => item.Empresa)
.Where(t => t.id == idTalonera)
.FirstOrDefault();
ViewBag.Talonera = talonera;
ClienteEntity cliente = _context.Cliente
.Where(c => c.id == idCliente)
.FirstOrDefault();
ViewBag.Cliente = cliente;
// generacion de numero de folio sugerido
Random rnd = new Random();
int folioSugerido = rnd.Next(talonera.RangoInicio, talonera.RangoFin);
ValeEntity valeValidacion = _context.Vale
.Where(v => v.Talonera.id == talonera.id && v.NumeroFolio == folioSugerido)
.FirstOrDefault();
while (valeValidacion != null)
{
folioSugerido = rnd.Next(talonera.RangoInicio, talonera.RangoFin);
valeValidacion = _context.Vale
.Where(v => v.Talonera.id == talonera.id && v.NumeroFolio == folioSugerido)
.FirstOrDefault();
}
ViewBag.FolioSugerido = folioSugerido;
// termina generacion de numero de folio sugerido
if (talonera.Empresa.NombreEmpresa != "Nombre Pendiente...")
{
ViewBag.EmpresaDisplay = talonera.Empresa.NombreEmpresa;
}
else
{
ViewBag.EmpresaDisplay = talonera.Empresa.Email;
}
return(View());
}
//CREATE
public ClienteEntity Create(ClienteEntity c)
{
using (PetManiaDBEntities db = new PetManiaDBEntities())
{
var cliente = clienteRepository.Create(db, c);
c.IdCliente = cliente.IdCliente;
db.SaveChanges();
return(c);
}
}
public void Modificar(ClienteEntity cliente)
{
ClienteTableAdapter adapter = new ClienteTableAdapter();
adapter.Modificar(
cliente.RazonSocial, cliente.NombreContacto,
cliente.MailContacto, cliente.Direccion,
cliente.Telefono, cliente.Actividad.Id,
cliente.Tipo.Id, cliente.Rut);
}
private void CrearParametros(OdbcCommand command, ClienteEntity entidad)
{
OdbcParameter parameter = null;
parameter = command.Parameters.Add("?", OdbcType.Int);
parameter.Value = entidad.IdUsuario;
parameter = command.Parameters.Add("?", OdbcType.VarChar);
parameter.Value = entidad.Dni;
}
public async Task <ClienteEntity> Add(ClienteEntity entity)
{
//throw new Exception("error prueba");
await _teleSoftDBContext.Clientes.AddAsync(entity);
await _teleSoftDBContext.SaveChangesAsync();
return(entity);
}
public HttpResponseMessage Update([FromBody] ClienteDTO cliente)
{
using (var context = new TexteContext())
{
ClienteEntity clienteEntity = Mapper.Map <ClienteDTO, ClienteEntity>(cliente);
var clientes = context.Entry(clienteEntity).State = EntityState.Modified;
context.SaveChanges();
return(Request.CreateResponse(HttpStatusCode.OK, cliente, "application/json"));
}
}
public List <ClienteEntity> ListarClientes(ClienteEntity oCliente)
{
List <ClienteEntity> returnListClienteEntity = new List <ClienteEntity>();
returnListClienteEntity = base.ListarClientes(oCliente);
return(returnListClienteEntity);
}
private static ClienteEntity LoadCustomer(IDataReader reader)
{
ClienteEntity customer = new ClienteEntity();
customer.PCodigo_Cliente = Convert.ToString(reader["CODIGO_CLIENTE_GLOBAL"]);
customer.PIdentificacion = Convert.ToString(reader["IDENTIFICACION"]);
customer.PNombres = Convert.ToString(reader["nombres"]);
return(customer);
}
static void Main(string[] args)
{
//exemplos abstratos
var cliente = new ClienteEntity();
cliente.DataCriacao = DateTime.Now;
//exemplos sealed
var request = new ProdutoRequest();
var rbase = new RequestBase();
}
/// <summary>
/// Insere um cliente
/// </summary>
/// <param name="entity">objeto a ser inserido</param>
public void Insert(ClienteEntity entity)
{
//Sempre valida o parametro
if (entity == null) throw new ArgumentNullException(nameof(entity));
//Verifica se pode inserir
VerifyIfCanInsert(entity);
//Insere na base
_clienteRepository.Insert(entity);
}
public static ClienteModel FromEntity(ClienteEntity entity)
{
return(new ClienteModel
{
Id = entity.Id,
Codigo = entity.Codigo,
Nome = entity.Nome,
Cpf = entity.Cpf,
DataNascimento = entity.DataNascimento.ToString("dd/MM/yyyy")
});
}
/// <summary>
/// Exclui um cliente
/// </summary>
/// <param name="entity">objeto a ser Excluido</param>
public void Delete(ClienteEntity entity)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
VerifyIfCanDelete(entity);
_clienteRepository.Delete(entity);
}
public void InsertLogAcessoLoginAluno_ComAcessoMEDELETRO()
{
string register = "50012816019";
Cliente cliente = new Cliente();
cliente.Register = register;
List <Cliente> clientes = new ClienteEntity().GetByFilters(cliente, 0, Aplicacoes.MEDELETRO);
Assert.IsTrue(clientes.Count > 0);
}
public ClienteEntity IncluirCliente(ClienteEntity cliente)
{
ClienteEntity _cliente = ObterClientePorCPF(cliente.Cpf);
if (_cliente != null)
{
throw new Exception("Cliente já existe");
}
return(_clienteDao.IncluirCliente(cliente));
}
/// <summary>
/// Verifica se o cliente pode ser inserido
/// </summary>
/// <param name="entity">Cliente</param>
private void VerifyIfCanInsert(ClienteEntity entity)
{
if (entity == null) throw new ArgumentNullException(nameof(entity));
var existingEntity = _clienteRepository.GetById(entity.Id);
if (existingEntity != null)
throw new ArgumentException(
string.Format(Messages.DuplicatedEntity,
AppExemplo.Core.Cadastro.Messages.ClienteEntity), nameof(entity));
}
public ClienteViewModel GetViewModel(ClienteEntity entity)
{
var viewModel = new ClienteViewModel();
viewModel.Id = entity.Id;
viewModel.NomeFantasia = entity.NomeFantasia;
viewModel.RazaoSocial = entity.RazaoSocial;
viewModel.Cnpj = entity.Cnpj;
viewModel.Email = entity.Email;
viewModel.Telefone1 = entity.Telefone1;
viewModel.Telefone2 = entity.Telefone2;
viewModel.NomeResponsavel = entity.NomeResponsavel;
viewModel.Loja = entity.Loja;
viewModel.CodEndereco = entity.CodEndereco;
return viewModel;
}
public ClienteEntity SetEntity(ClienteViewModel viewModel)
{
Check.Arg.IsNotNull(() => viewModel);
Check.Arg.IsNotNull(() => viewModel.Endereco);
var entity = new ClienteEntity();
entity.Id = viewModel.Id;
entity.NomeFantasia = viewModel.NomeFantasia;
entity.RazaoSocial = viewModel.RazaoSocial;
entity.Cnpj = viewModel.Cnpj;
entity.Email = viewModel.Email;
entity.Telefone1 = viewModel.Telefone1;
entity.Telefone2 = viewModel.Telefone2;
entity.NomeResponsavel = viewModel.NomeResponsavel;
entity.Loja = viewModel.Loja;
entity.CodEndereco = viewModel.CodEndereco;
return entity;
}
public PedidoEntity GetByClienteProduto(ClienteEntity cliente, ProdutoEntity produto)
{
return _context.PedidoEntities.SingleOrDefault(x => x.Cliente == cliente && x.Produto == produto);
}
public void Delete(ClienteEntity criteria)
{
repositoryManager.Delete(criteria);
}
public ClienteEntity Create(ClienteEntity entity)
{
return repositoryManager.Create(entity);
}
public void SaveClientesAgrupamento(ClienteEntity[] clientesAgrupamento)
{
foreach (var cliente in clientesAgrupamento)
repositoryManager.Update(cliente);
}
public ClienteEntity Update(ClienteEntity entity)
{
return repositoryManager.Update(entity);
}
public IEnumerable<PedidoEntity> ConsultarPedidoPorCliente(ClienteEntity Cliente)
{
return _pedidoRepository.GetByCliente(Cliente);
}
public PedidoEntity ConsultarPedidoPorId(ClienteEntity Cliente, ProdutoEntity Produto)
{
return _pedidoRepository.GetByClienteProduto(Cliente,Produto);
}
public void DeletarPedido(ClienteEntity Cliente, ProdutoEntity Produto)
{
_pedidoRepository.Delete(Cliente, Produto);
}
public void Add(ClienteEntity entity)
{
_context.ClienteEntities.Add(entity);
}
public IEnumerable<PedidoEntity> GetByCliente(ClienteEntity cliente)
{
return _context.PedidoEntities.Where(x => x.Cliente == cliente).ToList();
}
public void Delete(ClienteEntity cliente, ProdutoEntity produto)
{
var item = GetByClienteProduto(cliente,produto);
_context.PedidoEntities.Remove(item);
}
/// <summary>
/// Exclui um cliente
/// </summary>
/// <param name="entity">objeto a ser Excluido</param>
public void Delete(ClienteEntity entity)
{
if (entity == null) throw new ArgumentNullException(nameof(entity));
VerifyIfCanDelete(entity);
_clienteRepository.Delete(entity);
}
public void Add(ClienteDto dto)
{
var entity = new ClienteEntity(dto.Nome);
entity.DataNascimento = dto.DataNascimento;
_clienteRepository.Add(entity);
}
public void Update(ClienteEntity entity)
{
_context.Entry(entity).State = EntityState.Modified;
_context.SaveChanges();
}
public static PedidoEntity Create(ClienteEntity cliente, ProdutoEntity produto, int quantidade)
{
return new PedidoEntity(cliente,produto,quantidade);
}
