public void EditarCliente(ClienteDTO Cliente)
        {
            /*Solo se pueden editar los clientes habilitados*/

            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos nuestro cliente en la base de datos
                var miCliente = (from unCliente in miBase.Cliente where unCliente.cedula == Cliente.Cedula select unCliente).First();

                //Fijamos el cliente
                miBase.Cliente.Attach(miCliente);

                //Remapeamos sus datos
                miCliente.cedula          = Cliente.Cedula;
                miCliente.domicilio       = Cliente.Domicilio;
                miCliente.fechaNacimiento = Cliente.FechaNacimiento;
                miCliente.nickUsuario     = Cliente.NickUsuario;
                miCliente.nombre          = Cliente.Nombre;
                //Solo editamos los clientes habilitados, por tanto el cliente actual.habilitado = true
                miCliente.habilitado = true;

                //Guardamos los cambios que acabamos de hacer
                miBase.SaveChanges();
            }
        }
Exemplo n.º 2
0
        //Editar
        public void ActualizarUsuario(UsuarioDTO usr)
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //EL USUARIO A EDITAR NO PUEDE SER EL SUPERADMIN
                if (usr.Usuario.Trim().ToLower() != "superadmin")
                {
                    //Buscamos el usuario en la base de datos
                    var usrActualizar = miBase.Usuario.Where(p => p.Usuario1 == usr.Usuario).FirstOrDefault();

                    //Fijamos el usuario
                    miBase.Usuario.Attach(usrActualizar);

                    //Mapeamos sus datos
                    usrActualizar.Usuario1   = usr.Usuario;
                    usrActualizar.Contrasena = usr.Contrasena;
                    usrActualizar.EsAdmin    = usr.EsAdmin;
                    //Solo editamos usuarios habilitados
                    usrActualizar.habilitado = true;

                    //Guardamos los cambios
                    miBase.SaveChanges();
                }
            }
        }
Exemplo n.º 3
0
        public List <ProductoDTO> ListaProductos()
        {
            /*Devuelve la lista de productos esten registrados o no*/

            //Instanciamos la base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Traemos desde la base de datos la lista de productos convertida a List<ProductoDTO>
                var lista = from unProducto in miBase.Producto
                            select new ProductoDTO()
                {
                    Id          = unProducto.id,
                    Nombre      = unProducto.nombre,
                    Marca       = unProducto.marca,
                    NickUsuario = unProducto.nickUsuario,
                    Precio      = unProducto.precio,
                    Habilitado  = unProducto.habilitado
                };

                //Si la lista es nula retornamos null, sino retornamos la lista
                if (lista != null)
                {
                    return(lista.ToList());
                }
                else
                {
                    return(null);
                }
            }
        }
        public ClienteDTO BuscarCliente(int cedula)
        {
            /*Busca los clientes esten activos o no*/

            //Instanciamos la base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos el cliente
                var unCliente = miBase.Cliente.Where(c => c.cedula == cedula && c.habilitado == true).FirstOrDefault();

                //Vemos si NO encontramos un cliente
                if (unCliente == null)
                {
                    return(null);
                }
                else //Si efectivamente encontramos un cliente
                {
                    //Creamos el cliente Resultante
                    ClienteDTO resultado = new ClienteDTO
                    {
                        Cedula          = unCliente.cedula,
                        Nombre          = unCliente.nombre,
                        Domicilio       = unCliente.domicilio,
                        FechaNacimiento = unCliente.fechaNacimiento,
                        NickUsuario     = unCliente.nickUsuario,
                        Habilitado      = unCliente.habilitado
                    };

                    //Devolvemos el cliente resultado
                    return(resultado);
                }
            }
        }
        public List <ClienteDTO> ListaClientes()
        {
            /*Devuelve una lista de ClienteDTO esten habilitados o no*/

            //Instanciamos la base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Haciendo una consulta linQ creamos una lista con todos los clientes existentes
                var lista = (from unCliente in miBase.Cliente
                             select new ClienteDTO()
                {
                    Cedula = unCliente.cedula,
                    Nombre = unCliente.nombre,
                    Domicilio = unCliente.domicilio,
                    FechaNacimiento = unCliente.fechaNacimiento,
                    NickUsuario = unCliente.nickUsuario,
                    Habilitado = unCliente.habilitado
                });

                //Si la lista es nula retornamos null, sino retornamos la lista
                if (lista != null)
                {
                    return(lista.ToList());
                }
                else
                {
                    return(null);
                }
            }
        }
        public void AgregarFactura(FacturaDTO miFactura)
        {
            /*Creamos el principio de la factura con los datos que podemos agregar*/
            Factura nuevaFactura = new Factura()
            {
                fecha         = miFactura.Fecha,
                numeroCliente = miFactura.NumeroCliente,
                total         = miFactura.Total,
                nickUsuario   = miFactura.NickUsuario
            };

            using (BaseSistema miBase = new BaseSistema())
            {
                miBase.Factura.Add(nuevaFactura);
                miBase.SaveChanges();

                foreach (var item in miFactura.ListaDetalle)
                {
                    /*Creamos detalle por detalle y lo vamos agregando*/
                    DetallesFactura nuevoDetalle = new DetallesFactura()
                    {
                        cantidad   = item.Cantidad,
                        idProducto = item.IdProducto,
                        subTotal   = item.SubTotal,

                        /*El id de la factura es el mismo y se genero automatico cuando agregue la factura*/
                        factura = nuevaFactura.numeroFactura
                    };
                    miBase.DetallesFactura.Add(nuevoDetalle);
                }

                /*Guardamos los cambios*/
                miBase.SaveChanges();
            }
        }
Exemplo n.º 7
0
        public UsuarioDTO BuscarUsuario(string id)
        {
            /*Retorna un usuario, no importa si esta habilitado o no*/

            //Creamos el usuario resultante
            UsuarioDTO miUsuario;

            //Instanciamos la base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos el usuario en la base de datos
                var usuarioBase = miBase.Usuario.Where(usr => usr.Usuario1.Trim().ToLower() == id.Trim().ToLower()).FirstOrDefault();

                //Si no encontramos el usuario retornamos null:
                if (usuarioBase == null)
                {
                    miUsuario = null;
                }
                //Si encontramos el usuario hacemos el mapping correspondiente para pasarlo como UsuarioDTO:
                else
                {
                    //Creamos el usuario que devolveremos
                    miUsuario = new UsuarioDTO()
                    {
                        Usuario    = usuarioBase.Usuario1,
                        Contrasena = usuarioBase.Contrasena,
                        EsAdmin    = usuarioBase.EsAdmin,
                        Habilitado = usuarioBase.habilitado
                    };
                }
                //Retornamos el usuario resultante
                return(miUsuario);
            }
        }
Exemplo n.º 8
0
        public void EditarProducto(ProductoDTO unProducto)
        {
            /*Solo editamos productos habilitados*/

            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos el producto en nuestra base
                var productoEditar = miBase.Producto.Where(prod => prod.id == unProducto.Id).FirstOrDefault();

                //Lo fijamos (Nos paramos en el)
                miBase.Producto.Attach(productoEditar);

                //Re-Mapeamos su contenido con los datos nuevos
                productoEditar.id          = unProducto.Id;
                productoEditar.marca       = unProducto.Marca;
                productoEditar.nombre      = unProducto.Nombre;
                productoEditar.nickUsuario = unProducto.NickUsuario;
                productoEditar.precio      = unProducto.Precio;
                productoEditar.habilitado  = true; //Porque solo editamos productos habilitados

                //Salvamos los cambios
                miBase.SaveChanges();
            }
        }
Exemplo n.º 9
0
        /*Datos*/
        public int ProductosRegistrados()
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Consultamos la cantidad de productos registrados
                var res = miBase.Producto.Count();

                //Devolvemos esa cantidad
                return(res);
            }
        }
Exemplo n.º 10
0
        /*DATOS*/
        public int TotalClientesRegistrados()
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Consultamos la cantidad de clientes registrados
                var res = miBase.Cliente.Count();

                //Devolvemos esa cantidad
                return(res);
            }
        }
Exemplo n.º 11
0
        /*****************
        *    DATOS      *
        *****************/

        //Retorna la suma de los totales de todas las facturas
        public decimal TotalFacturado()
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Calculamos la suma de todos los totales
                var res = miBase.Factura.Sum(m => m.total);

                //Retornamos el total
                return(res);
            }
        }
Exemplo n.º 12
0
        //Retorna la cantidad de facturas registradas
        public int FacturasRegistradas()
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Consultamos la cantidad de facturas registradas
                var res = miBase.Factura.Count();

                //Retornamos esa cantidad
                return(res);
            }
        }
Exemplo n.º 13
0
        public List <FacturaDTO> FacturasUsuario(string usuario)
        {
            //creamos la lista resultante
            List <FacturaDTO> resultado = new List <FacturaDTO>();

            using (BaseSistema miBase = new BaseSistema())
            {
                //Obtenemos la lista de facturas y el detalle al mismo tiempo
                foreach (Factura f in miBase.Factura)
                {
                    //Verificamos que el usuario sea el que nos pasan
                    if (f.nickUsuario.Trim().ToLower() == usuario.Trim().ToLower())
                    {
                        //Creamos la facturaDTO y le asignamos los valores de la Factura de la base
                        FacturaDTO miFactura = new FacturaDTO()
                        {
                            numeroFactura = f.numeroFactura,
                            NumeroCliente = f.numeroCliente,
                            Fecha         = f.fecha,
                            NickUsuario   = f.nickUsuario,
                            Total         = f.total,
                            ListaDetalle  = new List <DetalleFacturaDTO>()
                        };

                        //Ahora que tenemos una factura creada le agregamos su detalle, buscando en la lista de detalles
                        foreach (DetallesFactura d in miBase.DetallesFactura)
                        {
                            //Buscamos los detalles que correspondan a la factura actual
                            if (miFactura.numeroFactura == d.factura)
                            {
                                //Creamos un nuevo detalle con los datos que corresponden
                                DetalleFacturaDTO unDetalle = new DetalleFacturaDTO()
                                {
                                    Cantidad   = d.cantidad,
                                    IdFactura  = d.factura,
                                    IdProducto = d.idProducto,
                                    SubTotal   = d.subTotal
                                };
                                //Agregamos el detalle a la factura:
                                miFactura.ListaDetalle.Add(unDetalle);
                            }
                        }
                        //Agregamos (luego de ya haber agregado los datos y los detalles) la factura a la lista resultado
                        resultado.Add(miFactura);
                    }
                }
            }
            //retornamos la lista resultado que contiene la lista de facturas de la base de datos
            return(resultado);
        }
Exemplo n.º 14
0
        public FacturaDTO BuscarFactura(int numeroFactura)
        {
            //Creamos el resultado como null, luego si encontramos una factura le asignamos su valor
            FacturaDTO resultado = null;

            using (BaseSistema miBase = new BaseSistema())
            {
                //Obtenemos la lista de facturas y el detalle al mismo tiempo
                foreach (Factura f in miBase.Factura)
                {
                    //Buscamos la factura con el mismo id
                    if (f.numeroFactura == numeroFactura)
                    {
                        resultado = new FacturaDTO()
                        {
                            numeroFactura = f.numeroFactura,
                            NumeroCliente = f.numeroCliente,
                            Fecha         = f.fecha,
                            NickUsuario   = f.nickUsuario,
                            Total         = f.total,
                            ListaDetalle  = new List <DetalleFacturaDTO>()
                        };

                        //Ahora que tenemos una factura creada le agregamos su detalle, buscando en la lista de detalles
                        foreach (DetallesFactura d in miBase.DetallesFactura)
                        {
                            //Buscamos los detalles que correspondan a la factura actual
                            if (resultado.numeroFactura == d.factura)
                            {
                                //Creamos un nuevo detalle con los datos que corresponden
                                DetalleFacturaDTO unDetalle = new DetalleFacturaDTO()
                                {
                                    Cantidad   = d.cantidad,
                                    IdFactura  = d.factura,
                                    IdProducto = d.idProducto,
                                    SubTotal   = d.subTotal
                                };
                                //Agregamos el detalle a la factura:
                                resultado.ListaDetalle.Add(unDetalle);
                            }
                        }
                        //Retornamos la faltura terminando el ciclo, porque ya no necesitamos buscar mas
                        return(resultado);
                    }
                }
                //En caso de no encontrar ninguna se retornara null porque asi definimos resultado al principio:
                return(resultado);
            }
        }
Exemplo n.º 15
0
        //Habilitar
        public void HabilitarUsuario(string usr)
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos el usuario
                var usuarioBorrar = (from usuario in miBase.Usuario where usuario.Usuario1.Trim().ToLower() == usr.Trim().ToLower() select usuario).First();

                //Fijamos el usuario
                miBase.Usuario.Attach(usuarioBorrar);
                //Cambiamos habilitado a true
                usuarioBorrar.habilitado = true;
                //Guardamos los cambios
                miBase.SaveChanges();
            }
        }
Exemplo n.º 16
0
        public void HabilitarCliente(int Cliente)
        {
            /*Reactivamos el cliente deshabilitado, es muy similar a editar*/

            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos nuestro cliente en la base con una consulta lambda
                var miCliente = miBase.Cliente.Where(c => c.cedula == Cliente).First();
                //Fijamos el cliente
                miBase.Cliente.Attach(miCliente);
                //Dejamos todos los campos iguales salvo habilitado que pasa a ser true
                miCliente.habilitado = true;
                //Guardamos los cambios de la base
                miBase.SaveChanges();
            }
        }
Exemplo n.º 17
0
        public void HabilitarProducto(int Producto)
        {
            /*Restaura (vuelve a habilitar) un producto deshabilitado*/

            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos y seleccionamos el producto a habilitar
                var prodBorrar = (from unProd in miBase.Producto where unProd.id == Producto select unProd).First();

                //Fijamos el producto
                miBase.Producto.Attach(prodBorrar);

                //Cambiamos el valor de habilitado a true
                prodBorrar.habilitado = true;

                //Guardamos los cambios
                miBase.SaveChanges();
            }
        }
Exemplo n.º 18
0
        public void EliminarProducto(int id)
        {
            /*Toma el producto con esa id y cambia el valor de habilitado a false*/

            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos y seleccionamos el producto a eliminar
                var prodBorrar = (from unProd in miBase.Producto where unProd.id == id select unProd).First();

                //Fijamos el producto
                miBase.Producto.Attach(prodBorrar);

                //Cambiamos el valor de habilitado a false
                prodBorrar.habilitado = false;

                //Guardamos los cambios
                miBase.SaveChanges();
            }
        }
Exemplo n.º 19
0
        //Eliminar
        public void BorrarUsuario(string usr)
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //EL USUARIO A ELIMINAR NO PUEDE SER EL SUPERADMIN
                if (usr.Trim().ToLower() != "superadmin")
                {
                    //Buscamos el usuario
                    var usuarioBorrar = (from usuario in miBase.Usuario where usuario.Usuario1.Trim().ToLower() == usr.Trim().ToLower() select usuario).First();

                    //Fijamos el usuario
                    miBase.Usuario.Attach(usuarioBorrar);
                    //Cambiamos habilitado a false
                    usuarioBorrar.habilitado = false;
                    //Guardamos los cambios
                    miBase.SaveChanges();
                }
            }
        }
Exemplo n.º 20
0
 //Devolveremos la lista de productos que registro un cliente x que nos pasan por parametro
 public List <ProductoDTO> ProductosUsuario(string usuario)
 {
     //Instanciamos nuestra base de datos
     using (BaseSistema miBase = new BaseSistema())
     {
         //Creamos la lista de todos los productos que hayan sido registrados por el usuario
         var lista = from unProducto in miBase.Producto
                     where unProducto.nickUsuario.Trim().ToLower() == usuario.Trim().ToLower()
                     select new ProductoDTO()
         {
             Habilitado  = unProducto.habilitado,
             Id          = unProducto.id,
             Marca       = unProducto.marca,
             NickUsuario = unProducto.nickUsuario,
             Nombre      = unProducto.nombre,
             Precio      = unProducto.precio
         };
         //Devolvemos la lista que acabamos de crear
         return(lista.ToList());
     }
 }
Exemplo n.º 21
0
 //Crear
 public void CrearUsuario(UsuarioDTO usr)
 {
     //Instanciamos la base de datos:
     using (BaseSistema miBase = new BaseSistema())
     {
         //Creamos el usuario
         Usuario nuevoUsuario = new Usuario()
         {
             //Mapeamos la tabla, agregamos uno a uno los datos:
             Usuario1   = usr.Usuario,
             Contrasena = usr.Contrasena,
             EsAdmin    = usr.EsAdmin,
             //Como estamos creando un usuario este esta habilitado
             habilitado = true
         };
         //Agregamos el usuario
         miBase.Usuario.Add(nuevoUsuario);
         //Hacemos los cambios en la base de datos:
         miBase.SaveChanges();
     }
 }
Exemplo n.º 22
0
        //Devolver Lista
        public List <UsuarioDTO> ListaUsuarios()
        {
            /*Retorna una lista de usuarios, esten habilitados o no*/

            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Para cada usuario en la base creamos un usuarioDTO con los mismos valores:
                var listaResultante = from usuario
                                      in miBase.Usuario
                                      select new UsuarioDTO
                {
                    Contrasena = usuario.Contrasena,
                    EsAdmin    = usuario.EsAdmin,
                    Usuario    = usuario.Usuario1,
                    Habilitado = usuario.habilitado
                };

                //Retornamos la lista que acabamos de crear:
                return(listaResultante.ToList());
            }
        }
Exemplo n.º 23
0
        public List <ClienteDTO> ClientesUsuario(string usuario)
        {
            /*Devolveremos la lista de clientes que creo cierto usuario*/

            //Instanciamos la base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Haciendo una consulta linQ creamos una lista con todos los clientes existentes
                var lista = (from unCliente in miBase.Cliente where unCliente.nickUsuario.Trim().ToLower() == usuario.Trim().ToLower()
                             select new ClienteDTO()
                {
                    Cedula = unCliente.cedula,
                    Nombre = unCliente.nombre,
                    Domicilio = unCliente.domicilio,
                    FechaNacimiento = unCliente.fechaNacimiento,
                    NickUsuario = unCliente.nickUsuario,
                    Habilitado = unCliente.habilitado
                });

                //Retornamos la lista de clientes creados por el usuario
                return(lista.ToList());
            }
        }
Exemplo n.º 24
0
        public void CrearCliente(ClienteDTO nuevoCliente)
        {
            //Instanciamos nuestra Base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Pasamos nuestro ClienteDTO a Cliente
                Cliente miCliente = new Cliente()
                {
                    cedula          = nuevoCliente.Cedula,
                    nombre          = nuevoCliente.Nombre,
                    domicilio       = nuevoCliente.Domicilio,
                    fechaNacimiento = nuevoCliente.FechaNacimiento,
                    nickUsuario     = nuevoCliente.NickUsuario,
                    //Como lo estamos creando, esta habilitado
                    habilitado = true
                };

                //Agregamos el cliente a nuestra base
                miBase.Cliente.Add(miCliente);
                //Guardamos los cambios
                miBase.SaveChanges();
            }
        }
Exemplo n.º 25
0
        public void EliminarCliente(int Cliente)
        {
            //Instanciamos nuestra base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos nuestro cliente en la base de datos
                var miCliente = (from unCliente in miBase.Cliente where unCliente.cedula == Cliente select unCliente).First();

                //Fijamos el cliente
                miBase.Cliente.Attach(miCliente);

                //dejamos todo igual, solo cambiamos habilitado
                miCliente.cedula          = miCliente.cedula;
                miCliente.domicilio       = miCliente.domicilio;
                miCliente.fechaNacimiento = miCliente.fechaNacimiento;
                miCliente.nickUsuario     = miCliente.nickUsuario;
                miCliente.nombre          = miCliente.nombre;
                //Deshabilitamos el cliente
                miCliente.habilitado = false;

                //Guardamos los cambios que acabamos de hacer
                miBase.SaveChanges();
            }
        }
Exemplo n.º 26
0
        //Crear Producto
        public void CrearProducto(ProductoDTO nuevoProducto)
        {
            //Instanciamos la base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Creamos un Producto
                Producto unProducto = new Producto()
                {
                    id          = nuevoProducto.Id,
                    marca       = nuevoProducto.Marca,
                    nombre      = nuevoProducto.Nombre,
                    precio      = nuevoProducto.Precio,
                    nickUsuario = nuevoProducto.NickUsuario,
                    /*Esta habilitado porque lo estamos creando*/
                    habilitado = true
                };

                //Agregamos el producto a la base
                miBase.Producto.Add(unProducto);

                //Guardamos los cambios
                miBase.SaveChanges();
            }
        }
Exemplo n.º 27
0
        public ProductoDTO BuscarProducto(int idProducto)
        {
            /*Devolvera un productoDTO o null, sin importar si el producto esta habilitado o no*/

            //Creamos el producto resultante
            ProductoDTO miProducto;

            //Instanciamos la base de datos
            using (BaseSistema miBase = new BaseSistema())
            {
                //Buscamos el producto en la base
                var ProductoBase = miBase.Producto.Where(prod => prod.id == idProducto).FirstOrDefault();

                //Si no encontramos el producto retornamos null:
                if (ProductoBase == null)
                {
                    miProducto = null;
                }
                //Si encontramos el producto hacemos el mapping correspondiente para pasarlo a ProductoDTO:
                else
                {
                    miProducto = new ProductoDTO()
                    {
                        Id          = ProductoBase.id,
                        Marca       = ProductoBase.marca,
                        Nombre      = ProductoBase.nombre,
                        Precio      = ProductoBase.precio,
                        NickUsuario = ProductoBase.nickUsuario,
                        Habilitado  = ProductoBase.habilitado
                    };
                }

                //Devolvemos el producto
                return(miProducto);
            }
        }