Beispiel #1
0
        public List <EProducto> GetByFilter(string filter, string busqueda)
        {
            var Lista = new List <EProducto>();
            var query = "SELECT * FROM PRODUCTO WHERE " + filter + " LIKE '%" + busqueda + "%'";

            try
            {
                using (SqlConnection connection = new SqlConnection(cnx))
                {
                    connection.Open();
                    using (SqlCommand cmd = new SqlCommand(query, connection))
                    {
                        SqlDataReader reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            var Producto = new EProducto();
                            Producto.id             = Convert.ToInt16(reader.GetValue(0));
                            Producto.tipo           = reader.GetValue(2).ToString();
                            Producto.marca          = reader.GetValue(1).ToString();
                            Producto.precio         = Convert.ToDecimal(reader.GetValue(3));
                            Producto.precioUnitario = Convert.ToDecimal(reader.GetValue(7));
                            Producto.stock          = Convert.ToInt16(reader.GetValue(4));
                            Producto.stockMinimo    = Convert.ToInt16(reader.GetValue(5));
                            Lista.Add(Producto);
                        }
                    }
                }
                return(Lista);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #2
0
 public void Insert(EProducto producto)
 {
     try
     {
         using (SqlConnection connection = new SqlConnection(cnx))
         {
             connection.Open();
             var query = "INSERT INTO PRODUCTO (TIPO,MARCA,PRECIO,STOCK,STOCKMINIMO,IDPROVEEDOR,PRECIO_UNITARIO) VALUES (@pTIPO,@pMARCA,@pPRECIO,@pSTOCK,@pSTOCKMINIMO,@pIDPROVEEDOR,@pPRECIO_UNITARIO)";
             using (SqlCommand cmd = new SqlCommand(query, connection))
             {
                 cmd.Parameters.AddWithValue("@pTIPO", producto.tipo);
                 cmd.Parameters.AddWithValue("@pMARCA", producto.marca);
                 cmd.Parameters.AddWithValue("@pPRECIO", producto.precio);
                 cmd.Parameters.AddWithValue("@pSTOCK", producto.Cantidad);
                 cmd.Parameters.AddWithValue("@pSTOCKMINIMO", producto.stockMinimo);
                 cmd.Parameters.AddWithValue("@pIDPROVEEDOR", producto.idProveedor);
                 cmd.Parameters.AddWithValue("@pPRECIO_UNITARIO", producto.precioUnitario);
                 cmd.ExecuteNonQuery();
             }
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Beispiel #3
0
        public EProducto GetByID(int id)
        {
            var query = "SELECT * FROM PRODUCTO WHERE ID = " + id.ToString();

            try
            {
                var Producto = new EProducto();
                using (var connection = new SqlConnection(cnx))
                {
                    connection.Open();
                    using (var command = new SqlCommand(query, connection))
                    {
                        SqlDataReader reader = command.ExecuteReader();
                        while (reader.Read())
                        {
                            Producto.id             = Convert.ToInt16(reader.GetValue(0));
                            Producto.tipo           = reader.GetValue(2).ToString();
                            Producto.marca          = reader.GetValue(1).ToString();
                            Producto.precio         = Convert.ToDecimal(reader.GetValue(3));
                            Producto.precioUnitario = Convert.ToDecimal(reader.GetValue(7));
                            Producto.Cantidad       = Convert.ToInt16(reader.GetValue(4));
                            Producto.stockMinimo    = Convert.ToInt16(reader.GetValue(5));
                            //Producto.idProveedor = Convert.ToInt16(reader.GetValue(6));
                            return(Producto);
                        }
                    }
                }
                throw new Exception("El producto no existe.");
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Beispiel #4
0
 public void insertar(EProducto producto)
 {
     try
     {
         con.ConnectionString = Conexion.cn;
         con.Open();
         MySqlCommand cmd = con.CreateCommand();
         cmd.CommandText = "INSERT INTO producto (nombre,concentracion, presentacion,fechavenc,centro,lote,reg_invima, forma, idlaboratorio, idcategoria, estado) value (@param1,@param2,@param3,@param4,@param5,@param6,@param7,@param8,@param9,@param10,@param11)";
         cmd.Parameters.AddWithValue("@param1", producto.Nombre);
         cmd.Parameters.AddWithValue("@param2", producto.concentracion);
         cmd.Parameters.AddWithValue("@param3", producto.presentacion);
         cmd.Parameters.AddWithValue("@param4", producto.fechav);
         cmd.Parameters.AddWithValue("@param5", producto.centro);
         cmd.Parameters.AddWithValue("@param6", producto.lote);
         cmd.Parameters.AddWithValue("@param7", producto.invima);
         cmd.Parameters.AddWithValue("@param8", producto.forma);
         cmd.Parameters.AddWithValue("@param9", producto.idlab);
         cmd.Parameters.AddWithValue("@param10", producto.idcat);
         cmd.Parameters.AddWithValue("@param11", producto.estado);
         cmd.ExecuteNonQuery();
         con.Close();
     }
     catch (Exception ex)
     {
         Console.Write(ex.ToString());
     }
 }
Beispiel #5
0
        public List <EProducto> GetAll()
        {
            var lista = new List <EProducto>();
            var query = "GETPRODUCTOS";

            try
            {
                using (var connection = new SqlConnection(cnx))
                {
                    connection.Open();
                    using (var command = new SqlCommand(query, connection))
                    {
                        SqlDataReader reader = command.ExecuteReader();
                        while (reader.Read())
                        {
                            var Producto = new EProducto();
                            Producto.id             = Convert.ToInt16(reader.GetValue(0));
                            Producto.tipo           = reader.GetValue(2).ToString();
                            Producto.marca          = reader.GetValue(1).ToString();
                            Producto.precio         = Convert.ToDecimal(reader.GetValue(3));
                            Producto.precioUnitario = Convert.ToDecimal(reader.GetValue(7));
                            Producto.stock          = Convert.ToInt16(reader.GetValue(4));
                            Producto.stockMinimo    = Convert.ToInt16(reader.GetValue(5));
                            //Producto.idProveedor = Convert.ToInt16(reader.GetValue(6));
                            lista.Add(Producto);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return(lista);
        }
        public List <EProducto> GetAll()
        {
            List <EProducto> productos = new List <EProducto>();

            using (SqlConnection cnx = new SqlConnection(ConfigurationManager.ConnectionStrings["miPrimeraVezConnectionString"].ToString()))
            {
                cnx.Open();

                const string sqlQuery = "SELECT * FROM Producto ORDER BY Id ASC";
                using (SqlCommand cmd = new SqlCommand(sqlQuery, cnx))
                {
                    SqlDataReader dataReader = cmd.ExecuteReader();
                    //
                    //Preguntamos si el DataReader fue devuelto con datos
                    while (dataReader.Read())
                    {
                        //
                        //Instanciamos al objeto Eproducto para llenar sus propiedades
                        EProducto producto = new EProducto
                        {
                            Id          = Convert.ToInt32(dataReader["Id"]),
                            Descripcion = Convert.ToString(dataReader["Descripcion"]),
                            Marca       = Convert.ToString(dataReader["Marca"]),
                            Precio      = Convert.ToDecimal(dataReader["Precio"])
                        };
                        //
                        //Insertamos el objeto Producto dentro de la lista Productos
                        productos.Add(producto);
                    }
                }
            }
            return(productos);
        }
        public void AddItems(EProducto producto, int Existencia, double ValorUnitario)
        {
            bool nuevo = true;

            if (MLVDetalle.Items.Count > 0)
            {
                foreach (ListViewItem items in MLVDetalle.Items)
                {
                    if (items.SubItems[0].Text.Equals(producto.Codigo))
                    {
                        int cantidad = Convert.ToInt32(items.SubItems[4].Text) + Existencia;
                        items.SubItems[3].Text = ValorUnitario.ToString();
                        items.SubItems[4].Text = cantidad.ToString();
                        items.SubItems[5].Text = (ValorUnitario * cantidad).ToString();
                        nuevo = false;
                    }
                }
            }
            if (nuevo == true)
            {
                ListViewItem Items = new ListViewItem(producto.Codigo);
                Items.SubItems.Add(producto.Nombre);
                Items.SubItems.Add(producto.UnidadMedida);
                Items.SubItems.Add(ValorUnitario.ToString());
                Items.SubItems.Add(Existencia.ToString());
                Items.SubItems.Add((ValorUnitario * Existencia).ToString());
                MLVDetalle.Items.Add(Items);
            }
            ActualizarResumen();
        }
Beispiel #8
0
        /// <summary>
        /// Lee la tabla indicada de la base y devuelve una lista con los registros que tenga la tabla.
        /// </summary>
        /// <returns></returns>
        public List <EmisorDeEmails> Leer()
        {
            List <EmisorDeEmails> lstEmisores = new List <EmisorDeEmails>();
            EmisorDeEmails        emisor;

            string consulta = String.Format("Select * from Emails2");

            try
            {
                comando.CommandText = consulta;
                conexion.Open();
                SqlDataReader oDr = comando.ExecuteReader();

                while (oDr.Read())
                {
                    string    mensaje  = oDr["Mensaje"].ToString();
                    EProducto producto = (EProducto)Enum.Parse(typeof(EProducto), oDr["Producto"].ToString());
                    //EProducto producto = (EProducto)oDr["Producto"];
                    string email = oDr["Email"].ToString();
                    emisor = new EmisorDeEmails(mensaje, producto, email);
                    lstEmisores.Add(emisor);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                conexion.Close();
            }

            return(lstEmisores);
        }
        public EProducto GetByid(int idProducto)
        {
            //var cadena = ConfigurationManager.ConnectionStrings["miPrimeraVezConnectionString"].ConnectionString;

            using (SqlConnection cnx = new SqlConnection(ConfigurationManager.ConnectionStrings["miPrimeraVezConnectionString"].ConnectionString))
            {
                cnx.Open();

                const string sqlGetById = "SELECT * FROM Producto WHERE Id = @id";
                using (SqlCommand cmd = new SqlCommand(sqlGetById, cnx))
                {
                    //
                    //Utilizamos el valor del parámetro idProducto para enviarlo al parámetro declarado en la consulta
                    //de selección SQL
                    cmd.Parameters.AddWithValue("@id", idProducto);
                    //
                    SqlDataReader dataReader = cmd.ExecuteReader();
                    if (dataReader.Read())
                    {
                        EProducto producto = new EProducto
                        {
                            Id          = Convert.ToInt32(dataReader["Id"]),
                            Descripcion = Convert.ToString(dataReader["Descripcion"]),
                            Marca       = Convert.ToString(dataReader["Marca"]),
                            Precio      = Convert.ToDecimal(dataReader["Precio"])
                        };

                        return(producto);
                    }
                }
            }

            return(null);
        }
Beispiel #10
0
        public EProducto ObtenerProducto(string codigobarra)
        {
            EProducto productoEncontrado = null;
            string    sql = "SELECT * FROM producto WHERE CodigoBarra = @cod";

            using (SqlConnection con = new SqlConnection("Data Source=(local);Initial Catalog=DBCFFLORES;Integrated Security=SSPI;"))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@cod", codigobarra));
                    using (SqlDataReader resultado = com.ExecuteReader())
                    {
                        if (resultado.Read())
                        {
                            productoEncontrado = new EProducto()
                            {
                                codigobarra    = (string)resultado["CodigoBarra"],
                                NombreProducto = (string)resultado["Nombre"],
                                Stock          = Int32.Parse(resultado["Stock"].ToString())
                            };
                        }
                    }
                }
            }
            return(productoEncontrado);
        }
Beispiel #11
0
        /// <summary>
        /// Expone los datos del elemento y su lista (incluidas sus herencias)
        /// SOLO del tipo requerido
        /// </summary>
        /// <param name="c">Elemento a exponer</param>
        /// <param name="ETipo">Tipos de ítems de la lista a mostrar</param>
        /// <returns></returns>
        public string Mostrar(Changuito c, EProducto tipo) //quitar static
        {
            StringBuilder sb = new StringBuilder();

            sb.AppendFormat("Tenemos {0} lugares ocupados de un total de {1} disponibles", c._productos.Count, c._espacioDisponible);
            sb.AppendLine("");
            foreach (Producto v in c._productos)
            {
                switch (tipo)
                {
                case EProducto.Snacks:
                    sb.AppendLine(v.Mostrar());
                    break;

                case EProducto.Dulce:
                    sb.AppendLine(v.Mostrar());
                    break;

                case EProducto.Leche:
                    sb.AppendLine(v.Mostrar());
                    break;

                default:
                    sb.AppendLine(v.Mostrar());
                    break;
                }
            }

            return(sb.ToString());
        }
Beispiel #12
0
        public ActionResult QuitardelCarrito(EProducto p)
        {
            var              resultado = p;
            ECarrito         carrito   = new ECarrito();
            List <EProducto> lp        = new List <EProducto>();
            List <EProducto> lpf       = new List <EProducto>();

            if (Session["listaCompra"] != null)
            {
                carrito = (ECarrito)Session["listaCompra"];
                lp      = carrito.productos;
                foreach (var pro in lp)
                {
                    if (pro.idProducto != p.idProducto)
                    {
                        lpf.Add(pro);
                        carrito.productos = lpf;
                    }
                }
                carrito.mensaje        = "Producto Quitado Exitosamente";
                Session["listaCompra"] = carrito;
            }
            //var res = Session["listaCompra"];
            return(Json(carrito, JsonRequestBehavior.DenyGet));
        }
Beispiel #13
0
 public EProducto Seleccionar(string Codigo)
 {
     try
     {
         SQLParameter[] parameters = new SQLParameter[1];
         parameters[0] = new SQLParameter("@Codigo", Codigo, SqlDbType.VarChar);
         DataRow   row = Conexion.ExecuteProcedureD("USP_S_SeleccionarProducto", parameters).Tables[0].Rows[0];
         EProducto be  = new EProducto
         {
             ID             = Convert.ToInt32(row[0]),
             Categoria      = Convert.ToInt32(row[1]),
             SubCategoria   = Convert.ToInt32(row[2]),
             Codigo         = row[3].ToString(),
             Nombre         = row[4].ToString(),
             Imagen         = row[5].ToString(),
             TipoExistencia = row[6].ToString(),
             UnidadMedida   = row[7].ToString(),
             Marca          = Convert.ToInt32(row[7]),
             Estado         = Convert.ToInt32(row[8].ToString())
         };
         return(be);
     }
     catch
     {
         EProducto be = new EProducto();
         return(be);
     }
 }
Beispiel #14
0
        public string Act_Producto(EProducto producto)
        {
            string  rpta = "";
            DataSet ds   = new DataSet();

            try
            {
                string query = "SP_ACTPRODUCTO";
                Dictionary <string, object> parameters = new Dictionary <string, object>();
                parameters.Add("@idproducto", producto.Idproducto);
                parameters.Add("@idcategoria", producto.Idcategoria);
                parameters.Add("@idproveedor", producto.Idproveedor);
                parameters.Add("@nombre", producto.Nombre);
                parameters.Add("@precio", producto.Precio);
                parameters.Add("@stock", producto.Stock);
                parameters.Add("@punto_reorden", producto.Punto_reorden);
                parameters.Add("@impuesto", producto.Impuesto);

                ds = dbconnection.execute_query(query, parameters);
                if (ds == null)
                {
                    rpta = ds.ToString();
                }
                else
                {
                    rpta = "REGISTRO REGISTRADO/ACTUALIZADO EXITOSAMENTE";
                }
            }
            catch (Exception ex)
            {
                rpta = ex.Message;
            }

            return(rpta);
        }
Beispiel #15
0
        public List <EProducto> Listar()
        {
            List <EProducto> List = new List <EProducto>();

            try
            {
                DataTable data = new DataTable();
                data = Conexion.ExecuteProcedureD("USP_S_ListarProducto").Tables[0];
                foreach (DataRow row in data.Rows)
                {
                    EProducto be = new EProducto
                    {
                        ID             = Convert.ToInt32(row[0]),
                        Categoria      = Convert.ToInt32(row[1]),
                        SubCategoria   = Convert.ToInt32(row[2]),
                        Codigo         = row[3].ToString(),
                        Nombre         = row[4].ToString(),
                        Imagen         = row[5].ToString(),
                        TipoExistencia = row[6].ToString(),
                        UnidadMedida   = row[7].ToString(),
                        Marca          = Convert.ToInt32(row[8]),
                        Estado         = Convert.ToInt32(row[9].ToString())
                    };
                    List.Add(be);
                }
            }
            catch
            {
                Console.WriteLine("No se encontro Procedimiento Almacenado");
            }
            return(List);
        }
Beispiel #16
0
        public List <EProducto> Buscar(string KeyWoard)
        {
            List <EProducto> List = new List <EProducto>();

            try
            {
                SQLParameter[] parameters = new SQLParameter[1];
                parameters[0] = new SQLParameter("@KeyWoard", KeyWoard, SqlDbType.VarChar);
                DataTable data = new DataTable();
                data = Conexion.ExecuteProcedureD("USP_S_BuscarProducto", parameters).Tables[0];
                foreach (DataRow row in data.Rows)
                {
                    EProducto be = new EProducto
                    {
                        ID             = Convert.ToInt32(row[0]),
                        Categoria      = Convert.ToInt32(row[1]),
                        SubCategoria   = Convert.ToInt32(row[2]),
                        Codigo         = row[3].ToString(),
                        Nombre         = row[4].ToString(),
                        Imagen         = row[5].ToString(),
                        TipoExistencia = row[6].ToString(),
                        UnidadMedida   = row[7].ToString(),
                        Marca          = Convert.ToInt32(row[7]),
                        Estado         = Convert.ToInt32(row[8].ToString())
                    };
                    List.Add(be);
                }
            }
            catch
            {
                Console.WriteLine("No se encontro Procedimiento Almacenado");
            }
            return(List);
        }
Beispiel #17
0
 public bool Agregar(EProducto obj)
 {
     SQLParameter[] parameters = new SQLParameter[9];
     parameters[0] = new SQLParameter("@Categoria", obj.Categoria, SqlDbType.Int);
     parameters[1] = new SQLParameter("@SubCategoria", obj.SubCategoria, SqlDbType.Int);
     parameters[2] = new SQLParameter("@Codigo", obj.Codigo, SqlDbType.VarChar);
     parameters[3] = new SQLParameter("@Nombre", obj.Nombre, SqlDbType.VarChar);
     parameters[4] = new SQLParameter("@Imagen", obj.Imagen, SqlDbType.VarChar);
     parameters[5] = new SQLParameter("@TipoExistencia", obj.TipoExistencia, SqlDbType.VarChar);
     parameters[6] = new SQLParameter("@UnidadMedida", obj.UnidadMedida, SqlDbType.VarChar);
     parameters[7] = new SQLParameter("@Marca", obj.Marca, SqlDbType.Int);
     parameters[8] = new SQLParameter("@Estado", obj.Estado, SqlDbType.Int);
     Response      = Conexion.ExecuteProcedureB("USP_I_AgregarProducto", parameters);
     if (Response == true)
     {
         EInventario beIventario = new EInventario
         {
             Producto        = obj.Codigo,
             ValorUnitario   = 0,
             Existencias     = 0,
             ValorInventario = 0
         };
         NInventario boInventario = new NInventario();
         boInventario.Agregar(beIventario);
     }
     return(Response);
 }
        //
        //Creamos los métodos generales llenando y leyendo objetos
        //
        private void Guardar()
        {
            try
            {
                if (_producto == null)
                {
                    _producto             = new EProducto();
                    _producto.Id          = Convert.ToInt32(txtId.Text);
                    _producto.Descripcion = txtDescripcion.Text;
                    _producto.Marca       = txtMarca.Text;
                    _producto.Precio      = Convert.ToDecimal(txtPrecio.Text);

                    _productoBol.Registrar(_producto);

                    if (_productoBol.stringBuilder.Length != 0)
                    {
                        MessageBox.Show(_productoBol.stringBuilder.ToString(), "Para continuar:");
                    }
                    else
                    {
                        MessageBox.Show("Producto registrado/actualizado con éxito");

                        TraerTodos();
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(string.Format("Error: {0}", ex.Message), "Error inesperado");
            }
        }
        private void Registrar()
        {
            EProducto producto = new EProducto();

            producto.Id                 = _idProducto;
            producto.Nombre             = txtNombre.Text;
            producto.Codigo             = txtCodigo.Text;
            producto.TipoProducto       = chkProducto.Checked ? 4 : 3;
            producto.Descripcion        = txtDescripcion.Text;
            producto.CostoManoObra      = Convert.ToDecimal(txtCostoBase.EditValue);
            producto.UtilidadPorcentaje = Convert.ToInt32(txtUtilidadPorce.EditValue);
            producto.PrecioVenta        = Convert.ToDecimal(txtPrecioReal.EditValue);


            var productoArticuloArreglo = new EProductoArticulo[viewArticulo.RowCount];

            for (var i = 0; i < viewArticulo.RowCount; i++)
            {
                EProductoArticulo productoArticulo = new EProductoArticulo
                {
                    IdArticulo = Convert.ToInt32(viewArticulo.GetRowCellValue(i, "id_articulo")),
                    Cantidad   = Convert.ToInt32(viewArticulo.GetRowCellValue(i, "cantidad"))
                };
                productoArticuloArreglo[i] = productoArticulo;
            }
            _productoLogico.Registrar(producto, productoArticuloArreglo);

            if (_productoLogico.StringBuilder.Length > 0)
            {
                XtraMessageBox.Show(_productoLogico.StringBuilder.ToString());
                return;
            }
            DialogResult = DialogResult.OK;
        }
Beispiel #20
0
        public ActionResult AgregaralCarrito(EProducto p)
        {
            var              resultado = p;
            ECarrito         carrito   = new ECarrito();
            List <EProducto> lp        = new List <EProducto>();

            if (Session["listaCompra"] != null)
            {
                carrito = (ECarrito)Session["listaCompra"];
                lp      = carrito.productos;
                foreach (var pr in lp)
                {
                    if (pr.idProducto != p.idProducto)
                    {
                        lp.Add(p);
                        carrito.mensaje        = "Producto agregado al Carrito";
                        Session["listaCompra"] = carrito;
                    }
                    else
                    {
                        carrito.mensaje = "Producto ya agregado al Carrito";
                    }
                }
            }
            else
            {
                lp.Add(p);
                carrito.productos      = lp;
                carrito.mensaje        = "Producto agregado al Carrito";
                Session["listaCompra"] = carrito;
            }
            //var res = Session["listaCompra"];
            //return Json(res, JsonRequestBehavior.DenyGet);
            return(Json(carrito, JsonRequestBehavior.DenyGet));
        }
 public void RegistrarPro(EProducto producto)
 {
     if (Validar(producto))
     {
         cdPro.Registrar(producto);
     }
 }
 public void EditarPro(EProducto producto)
 {
     if (Validar(producto))
     {
         cdPro.Editar(producto);
     }
 }
Beispiel #23
0
        /*
         * public EProducto CrearProducto(EProducto productoACrear)
         * {
         *  EProducto productoCreado = null;
         *  string sql = "INSERT INTO producto VALUES (@cod, @nom,@stock,@precio)";
         *  using (SqlConnection con = new SqlConnection(cadenaconexion))
         *  {
         *      con.Open();
         *      using (SqlCommand com = new SqlCommand(sql, con))
         *      {
         *          com.Parameters.Add(new SqlParameter("@cod", productoACrear.codigobarra));
         *          com.Parameters.Add(new SqlParameter("@nom", productoACrear.Nombre));
         *          com.Parameters.Add(new SqlParameter("@stock", productoACrear.Stock));
         *          com.Parameters.Add(new SqlParameter("@precio", productoACrear.Precio));
         *          com.ExecuteNonQuery();
         *      }
         *  }
         *  productoCreado = ObtenerProducto(productoACrear.codigobarra);
         *  return productoCreado;
         * }
         *
         * public EProducto ModificarProducto(EProducto productoACrear)
         * {
         *  EProducto productoCreado = null;
         *  string sql = "update producto set Nombre = @nom, Stock = @, precio = @Precio where CodigoBarra = @cod ";
         *  using (SqlConnection con = new SqlConnection(cadenaconexion))
         *  {
         *      con.Open();
         *      using (SqlCommand com = new SqlCommand(sql, con))
         *      {
         *          com.Parameters.Add(new SqlParameter("@cod", productoACrear.codigobarra));
         *          com.Parameters.Add(new SqlParameter("@nom", productoACrear.Nombre));
         *          com.Parameters.Add(new SqlParameter("@stock", productoACrear.Stock));
         *          com.Parameters.Add(new SqlParameter("@precio", productoACrear.Precio));
         *          com.ExecuteNonQuery();
         *      }
         *  }
         *  productoCreado = ObtenerProducto(productoACrear.codigobarra);
         *  return productoCreado;
         * }
         */
        public List <EProducto> ListarProducto()
        {
            List <EProducto> productoList = new List <EProducto>();
            EProducto        productobe   = null;
            string           sql          = "SELECT * FROM producto";

            using (SqlConnection con = new SqlConnection(cadenaconexion))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    using (SqlDataReader resultado = com.ExecuteReader())
                    {
                        while (resultado.Read())
                        {
                            productobe = new EProducto()
                            {
                                codigobarra = (string)resultado["CodigoBarra"].ToString(),
                                Nombre      = (string)resultado["Nombre"].ToString(),
                                Stock       = Int32.Parse(resultado["Stock"].ToString()),
                                Precio      = Double.Parse(resultado["Precio"].ToString()),
                                Estado      = (string)resultado["Estado"].ToString(),
                                Tipo        = (string)resultado["Tipo"]
                            };
                            productoList.Add(productobe);
                        }
                    }
                }
            }
            return(productoList);
        }
Beispiel #24
0
        public EProducto ObtenerProducto(string codigobarra)
        {
            EProducto productoEncontrado = null;
            string    sql = "SELECT * FROM producto WHERE CodigoBarra = @cod";

            using (SqlConnection con = new SqlConnection(cadenaconexion))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@cod", codigobarra));
                    using (SqlDataReader resultado = com.ExecuteReader())
                    {
                        if (resultado.Read())
                        {
                            productoEncontrado = new EProducto()
                            {
                                codigobarra = (string)resultado["CodigoBarra"],
                                Nombre      = (string)resultado["Nombre"],
                                Stock       = Int32.Parse(resultado["Stock"].ToString()),
                                Precio      = Double.Parse(resultado["Precio"].ToString()),
                                Estado      = (string)resultado["Estado"]
                            };
                        }
                    }
                }
            }
            return(productoEncontrado);
        }
Beispiel #25
0
        private void txtcodpro_Validating(object sender, CancelEventArgs e)
        {
            // fill customer data in validate method
            EProducto producto = new EProducto();

            // if txt codigo is empty go out
            if (txtcodpro.Text != string.Empty)
            {
                producto.Idproveedor = Convert.ToInt32(this.txtcodpro.Text.Trim());
            }
            else
            {
                return;
            }
            DataSet ds = new DataSet();

            ds = bus_producto.FilterbyID(producto);
            // if the dataset is filled, it means that there are data and we have to fill the fields
            // if not empty the fields
            if (utilites_presentation.isdataset_empty(ds) != true)
            {
                this.txtcodpro.Text  = ds.Tables[0].Rows[0]["idproducto"].ToString();
                this.txtnompro.Text  = ds.Tables[0].Rows[0]["nombre"].ToString();
                this.txtprevent.Text = ds.Tables[0].Rows[0]["precio"].ToString();
            }
            else
            {
                this.txtnompro.Text   = string.Empty;
                this.txtprevent.Text  = string.Empty;
                this.txtcantvent.Text = string.Empty;
            }
        }
Beispiel #26
0
 public void registrar(EProducto producto)
 {
     if (validarProducto(producto))
     {
         _dproducto.insertar(producto);
     }
 }
        private void consultar()
        {
            EProducto producto = new EProducto();

            producto.Nombre         = this.txtbuscar.Text.Trim();
            this.dgvdata.DataSource = bus_producto.FilterByName(producto).Tables[0];
            this.txtbuscar.Focus();
        }
        private void btn_buscar2_Click(object sender, EventArgs e)
        {
            EProducto producto = new EProducto();

            producto.Nombre = this.txtbuscar.Text.Trim();
            // filling datagriview with filter data
            this.dgvdata.DataSource = bus_producto.FilterByName(producto).Tables[0];
        }
Beispiel #29
0
        //private string cadenaconexion = "Data Source=LAPTOP-C3204AHJ\\SQLEXPRESS;Initial Catalog=CFFLORESDB;Integrated Security=True";
        public EProducto ObtenerProducto(string codigobarra, string nombre, string tipo)
        {
            EProducto productoEncontrado = null;
            string    sql = "";

            if (codigobarra.Length != 0 && nombre.Length != 0 && tipo.Length != 0)
            {
                sql = "SELECT * FROM producto WHERE CodigoBarra = @cod and nombre = @nom and tipo = @tip";
            }
            else if (codigobarra.Length != 0 && nombre.Length != 0 && tipo.Length == 0)
            {
                sql = "SELECT * FROM producto WHERE CodigoBarra = @cod and nombre = @nom";
            }
            else if (codigobarra.Length != 0 && nombre.Length == 0 && tipo.Length == 0)
            {
                sql = "SELECT * FROM producto WHERE CodigoBarra = @cod";
            }
            else if (codigobarra.Length == 0 && nombre.Length != 0 && tipo.Length != 0)
            {
                sql = "SELECT * FROM producto WHERE nombre = @nom and tipo = @tip";
            }
            else if (codigobarra.Length == 0 && nombre.Length == 0 && tipo.Length != 0)
            {
                sql = "SELECT * FROM producto WHERE tipo = @tip";
            }
            else if (codigobarra.Length == 0 && nombre.Length != 0 && tipo.Length == 0)
            {
                sql = "SELECT * FROM producto WHERE nombre = @nom ";
            }

            using (SqlConnection con = new SqlConnection(cadenaconexion))
            {
                con.Open();
                using (SqlCommand com = new SqlCommand(sql, con))
                {
                    com.Parameters.Add(new SqlParameter("@cod", codigobarra));
                    com.Parameters.Add(new SqlParameter("@nom", nombre));
                    com.Parameters.Add(new SqlParameter("@tip", tipo));
                    using (SqlDataReader resultado = com.ExecuteReader())
                    {
                        if (resultado.Read())
                        {
                            productoEncontrado = new EProducto()
                            {
                                codigobarra = (string)resultado["CodigoBarra"],
                                Nombre      = (string)resultado["Nombre"],
                                Stock       = Int32.Parse(resultado["Stock"].ToString()),
                                Precio      = Double.Parse(resultado["Precio"].ToString()),
                                Estado      = (string)resultado["Estado"],
                                Tipo        = (string)resultado["Tipo"]
                            };
                        }
                    }
                }
            }
            return(productoEncontrado);
        }
Beispiel #30
0
        public EProducto ObtenerProducto(string codigobarra)
        {
            EProducto ObProducto = new EProducto();

            ObProducto = daoproducto.ObtenerProducto(codigobarra);
            /*Se valida que exista Producto*/
            if (ObProducto == null)
            {
                throw new FaultException <ProductoInexistente>(
                          new ProductoInexistente()
                {
                    exCodigo = 10,
                    exError  = "El producto No existe"
                }
                          , new FaultReason("No existe el Producto"));
            }
            /*Se valida que exista Stock*/
            if (ObProducto.Stock == 0)
            {
                throw new FaultException <ProductoInexistente>(
                          new ProductoInexistente()
                {
                    exCodigo   = 11,
                    exProducto = ObProducto.Nombre.ToString(),
                    exError    = "El producto " + ObProducto.Nombre + " no cuenta con Stock disponible"
                }
                          , new FaultReason("El producto " + ObProducto.Nombre + " no cuenta con Stock disponible"));
            }
            /*Se valida que  se va agotar Stock*/
            if (ObProducto.Stock <= 10)
            {
                throw new FaultException <ProductoInexistente>(
                          new ProductoInexistente()
                {
                    exCodigo   = 12,
                    exProducto = ObProducto.Nombre.ToString(),
                    exError    = "El producto " + ObProducto.Nombre + " esta por agotarse"
                }
                          , new FaultReason("El producto " + ObProducto.Nombre + " esta por agotarse"));
            }
            /*Se valida que el producto este habilitado*/
            //0 : Habilitado
            //1: Deshabilitado
            if (String.IsNullOrEmpty(ObProducto.Estado) || ObProducto.Estado.Equals("1"))
            {
                throw new FaultException <ProductoInexistente>(
                          new ProductoInexistente()
                {
                    exCodigo   = 13,
                    exProducto = ObProducto.Nombre.ToString(),
                    exError    = "El producto " + ObProducto.Nombre + " esta Deshabilitado"
                }
                          , new FaultReason("El producto " + ObProducto.Nombre + " esta Deshabilitado"));
            }

            return(ObProducto);
        }