Example #1
0
        public ActionResult Detalle(short NumeroDeProducto)
        {
            if (!ValidaSesion())
            {
                return(RedirectToAction("LoginOut", "Account"));
            }
            if (!ValidaFuncionalidad(NumeroDePantalla, (byte)ClsEnumerables.Funcionalidades.DETALLE))
            {
                return(RedirectToAction("Index", "Producto"));
            }
            var           ProductoClase = ClsProductos.getList(String.Format("NumeroDeProducto == {0}", NumeroDeProducto));
            ProductoModel Producto      = new ProductoModel(ProductoClase.FirstOrDefault());

            if (Producto == null)
            {
                return(RedirectToAction("Index", "Producto"));
            }
            ViewBag.RutaDeCodigoDeBarras = "";
            ClsCodigosDeBarras CodigosDeBarras = (from q in ClsCodigosDeBarras.getList() where q.CodigoDeBarras == Producto.CodigoDeBarras && q.NumeroDeProducto == Producto.NumeroDeProducto select q).ToList().FirstOrDefault();

            if (CodigosDeBarras != null)
            {
                ViewBag.RutaDeCodigoDeBarras = CodigosDeBarras.RutaDeArchivo;
            }
            ViewBag.AplicarPrecioDeMayoreo = "SI";
            if (ClsConfiguraMayoreos.getList().Exists(x => x.NumeroDeProducto == Producto.NumeroDeProducto && x.CodigoDeBarras == Producto.CodigoDeBarras))
            {
                ViewBag.AplicarPrecioDeMayoreo = "NO";
            }
            this.CargaCombos(Producto);
            return(View(Producto));
        }
Example #2
0
        public JsonResult CargaTodosLosPrecios(String NombreOCodigoDeProducto)
        {
            var Productos = (from q in ClsProductos.getList() where q.CodigoDeBarras == NombreOCodigoDeProducto select q).FirstOrDefault();

            if (Productos == null)
            {
                Productos = (from q in ClsProductos.getList() where q.NombreDeProducto == NombreOCodigoDeProducto select q).FirstOrDefault();
            }
            List <Object> Precios = new List <object>();

            if (Productos != null)
            {
                Precios.Add(new { id = Productos.NumeroDeProducto, Tipo = "Precio Unitario", Campo = "Precio Unitario", Valor = Productos.PrecioUnitario });

                var PreciosMayoreo = (from q in ClsConfiguraMayoreos.getList() where q.NumeroDeProducto == Productos.NumeroDeProducto && q.CodigoDeBarras == Productos.CodigoDeBarras orderby q.NumeroDeMayoreo select q).ToList();
                foreach (var Mayoreo in PreciosMayoreo)
                {
                    Precios.Add(new { id = Mayoreo.NumeroDeMayoreo, Tipo = "Precio Mayoreo", Campo = String.Format("Precio Mayoreo de {0} a {1}", Mayoreo.CantidadMinima, (Mayoreo.CantidadMaxima == null ? "sin limite" : Mayoreo.CantidadMaxima.ToString())), Valor = Mayoreo.PrecioDeMayoreo });
                }
                var ConfiguraPaqueteP = (from q in ClsConfiguraPaquetes.getList() where q.NumeroDeProductoPadre == Productos.NumeroDeProducto select q).ToList();
                foreach (var ConfPaqueteP in ConfiguraPaqueteP)
                {
                    Precios.Add(new { id = ConfPaqueteP.NumeroDeProductoPadre.ToString() + "_" + ConfPaqueteP.NumeroDeProductoHijo.ToString(), Tipo = "Precio Paquete Padre", Campo = "Precio de Producto Padre", Valor = ConfPaqueteP.PrecioDeProductoPadre, CampoHijo = "Producto Hijo " + ConfPaqueteP.NombreDeProductoHijo, ValorHijo = ConfPaqueteP.PrecioDeProductoHijo });
                }
                var ConfiguraPaqueteH = (from q in ClsConfiguraPaquetes.getList() where q.NumeroDeProductoHijo == Productos.NumeroDeProducto select q).ToList();
                foreach (var ConfPaqueteH in ConfiguraPaqueteH)
                {
                    Precios.Add(new { id = ConfPaqueteH.NumeroDeProductoPadre.ToString() + "_" + ConfPaqueteH.NumeroDeProductoHijo.ToString(), Tipo = "Precio Paquete Hijo", Campo = "Precio de Producto Hijo", Valor = ConfPaqueteH.PrecioDeProductoHijo, CampoPadre = "Producto Padre " + ConfPaqueteH.NombreDeProductoPadre, ValorPadre = ConfPaqueteH.PrecioDeProductoPadre });
                }
            }

            return(Json(new { Precios }, JsonRequestBehavior.AllowGet));
        }
Example #3
0
 public JsonResult CorrigeLetraEne(String A, String R)
 {
     // ñ , ¥
     ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
     foreach (var producto in ClsProductos.getList().Where(x => x.NombreDeProducto.Contains(A)))
     {
         producto.NombreDeProducto = producto.NombreDeProducto.Replace(A, R);
         if (!producto.Update())
         {
             Resultado.Resultado = false;
             Resultado.Mensaje   = "Ocurrio un error al corregir " + R;
             return(Json(Resultado, JsonRequestBehavior.AllowGet));
         }
     }
     foreach (var producto in ClsProductos.getList().Where(x => x.Descripcion.Contains(A)))
     {
         producto.Descripcion = producto.Descripcion.Replace(A, R);
         if (!producto.Update())
         {
             Resultado.Resultado = false;
             Resultado.Mensaje   = "Ocurrio un error al corregir " + R;
             return(Json(Resultado, JsonRequestBehavior.AllowGet));
         }
     }
     return(Json(Resultado, JsonRequestBehavior.AllowGet));
 }
        protected void Button2_Click(object sender, EventArgs e)
        {
            ClsProductos p = new ClsProductos();

            string itemseleccionado = DropDownList1.SelectedItem.Text;

            p.pNombre    = txtnombre.Text;
            p.pPrecio    = double.Parse(txtprecio.Text);
            p.pCantidad  = int.Parse(txtcantidad.Text);
            p.pFechaVenc = txtfechanaci.Text;
            p.pTipo      = itemseleccionado;
            p.pImage     = txtUrlImage.Text;

            bool respuestasql = p.insertarProducto();

            if (respuestasql == true)
            {
                Response.Write("<script>alert('guardado')</script>");
                txtnombre.Text    = "";
                txtprecio.Text    = "";
                txtcantidad.Text  = "";
                txtfechanaci.Text = "";
            }
            else
            {
                Response.Write("<script>alert('Error al guardar')</script>");
            }
        }
Example #5
0
        public JsonResult CargaProducto(String NombreOCodigoDeProducto, short NumeroDeProducto = 0)
        {
            ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
            List <ClsProductos>       Productos = new List <ClsProductos>();
            ClsProductos Producto = new ClsProductos();

            if (NumeroDeProducto == 0)
            {
                Productos = ClsProductos.getList(String.Format("CodigoDeBarras == \"{0}\" && CveDeEstatus == {1}", NombreOCodigoDeProducto, (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO));
                if (Productos.Count() == 0)
                {
                    Productos = ClsProductos.getList(String.Format("NombreDeProducto == \"{0}\" && CveDeEstatus == {1}", NombreOCodigoDeProducto, (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO));
                }
            }
            else
            {
                Productos = ClsProductos.getList(String.Format("NumeroDeProducto == {0} && CveDeEstatus == {1}", NumeroDeProducto, (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO));
            }
            if (Productos.Count() == 0)
            {
                Resultado.Resultado = false;
                Resultado.Mensaje   = "No fue posible encontrar el producto";
            }
            else
            {
                Producto = Productos.FirstOrDefault();
            }
            return(Json(new { Resultado, Producto, Productos }, JsonRequestBehavior.AllowGet));
        }
Example #6
0
        public void ListarMarcas()
        {
            ClsProductos objPro = new ClsProductos();

            CmbMarca.DataSource    = objPro.ListarMarcas();
            CmbMarca.DisplayMember = "Marca";
            CmbMarca.ValueMember   = "Id_Marca";
        }
Example #7
0
        private void ListarMarcas()
        {
            ClsProductos objProd = new ClsProductos();

            CmbMarca.DataSource    = objProd.ListarMarcas();
            CmbMarca.DisplayMember = "MARCA";
            CmbMarca.ValueMember   = "IDMARCA";
        }
Example #8
0
        private void ListarUsuario()
        {
            ClsProductos objProd = new ClsProductos();
            cmbEncargado.DataSource = objProd.ListarUsuario();
            cmbEncargado.DisplayMember = "descripcion";
            cmbEncargado.ValueMember = "usuarioid";

        }
Example #9
0
        public void ListarCategorias()
        {
            ClsProductos objProd = new ClsProductos();

            CmbCategoria.DataSource    = objProd.ListarCategorias();
            CmbCategoria.DisplayMember = "Categoria";
            CmbCategoria.ValueMember   = "Id_Categ";
        }
Example #10
0
        private void ListarCategorias()
        {
            ClsProductos objProd = new ClsProductos();

            CmbCategoria.DataSource    = objProd.ListarCategorias();
            CmbCategoria.DisplayMember = "CATEGORIA";
            CmbCategoria.ValueMember   = "IDCATEG";
        }
Example #11
0
 public JsonResult CreaImagneCodigoDeBarras()
 {
     ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
     foreach (var Producto in ClsProductos.getList().Where(x => x.CodigoDeBarras.Contains("Kuup")).ToList().OrderBy(x => x.NumeroDeProducto))
     {
         Funciones.Kuup.CodigoDeBarras.MoCodigoDeBarras ResultadoCodigo = (new Funciones.Kuup.CodigoDeBarras.MoCodigoDeBarras()).GeneraCodigoDeBarras(Producto.NumeroDeProducto, "Kuup", Producto.CodigoDeBarras);
     }
     return(Json(Resultado, JsonRequestBehavior.AllowGet));
 }
Example #12
0
        public JsonResult UrlBuscaPrecioDeProducto(String CodigoONombreDeProducto)
        {
            String Filtro     = String.Format("NombreDeProducto == \"{0}\" && CveDeEstatus == 1", CodigoONombreDeProducto);
            var    Encontrado = ClsProductos.getList(Filtro);

            if (Encontrado.Count() == 0)
            {
                Filtro     = String.Format("CodigoDeBarras == \"{0}\" && CveDeEstatus == 1", CodigoONombreDeProducto);
                Encontrado = ClsProductos.getList(Filtro);
            }
            return(Json(new { NumeroDeProducto = Encontrado.FirstOrDefault().NumeroDeProducto, NombreDeProducto = Encontrado.FirstOrDefault().NombreDeProducto, CodigoDeBarras = Encontrado.FirstOrDefault().CodigoDeBarras, PrecioDeProducto = Encontrado.FirstOrDefault().PrecioUnitario }, JsonRequestBehavior.AllowGet));
        }
        private static ClsProductos filaDTOProducto(ProductosDS.ProductoRow filas)
        {
            ClsProductos objProducto = new ClsProductos();

            objProducto.nombre       = filas.Nombre;
            objProducto.idTipoProduc = filas.IdTipoProducto;
            objProducto.precio       = filas.Precio;
            objProducto.descripcion  = filas.Descripcion;
            objProducto.imagen       = filas.imagen;

            return(objProducto);
        }
Example #14
0
        public ActionResult Edita(short NumeroDeProducto, String CodigoDeBarras)
        {
            if (!ValidaSesion())
            {
                return(RedirectToAction("LoginOut", "Account"));
            }
            if (!ValidaFuncionalidad(NumeroDePantalla, (byte)ClsEnumerables.Funcionalidades.EDITA))
            {
                return(RedirectToAction("Detalle", "Producto", new { NumeroDeProducto }));
            }
            String Filtro = String.Empty;

            Filtro = String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\"", NumeroDeProducto, CodigoDeBarras);
            ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
            ProductoModel             productos = (from q in ClsProductos.getList(Filtro)
                                                   select new ProductoModel()
            {
                NumeroDeProducto = q.NumeroDeProducto,
                CodigoDeBarras = q.CodigoDeBarras,
                FechaDeRegistro = q.FechaDeRegistro,
                CantidadDeProductoUltima = q.CantidadDeProductoUltima,
                CantidadDeProductoNueva = q.CantidadDeProductoNueva,
                CantidadDeProductoTotal = q.CantidadDeProductoTotal,
                NombreDeProducto = q.NombreDeProducto,
                Descripcion = q.Descripcion,
                NumeroDeTipoDeProducto = q.NumeroDeTipoDeProducto,
                NumeroDeMarca = q.NumeroDeMarca,
                CveAviso = q.CveAviso,
                CveCorreoSurtido = q.CveCorreoSurtido,
                CantidadMinima = q.CantidadMinima,
                NumeroDeProveedor = q.NumeroDeProveedor,
                PrecioUnitario = q.PrecioUnitario,
                CveDeEstatus = q.CveDeEstatus,
                NombreDeTipoDeProducto = q.NombreDeTipoDeProducto,
                NombreDeMarca = q.NombreDeMarca,
                TextoAviso = q.TextoAviso,
                TextoCorreoSurtido = q.TextoCorreoSurtido,
                NombreDeProveedor = q.NombreDeProveedor,
                TextoDeEstatus = q.TextoDeEstatus
            }).FirstOrDefault();

            if (productos == null)
            {
                Resultado.Resultado   = false;
                Resultado.Mensaje     = "El producto no existe";
                TempData["Resultado"] = Resultado.MensajeController();
                return(RedirectToAction("Index", "Producto"));
            }
            this.CargaCombos(productos);
            return(View(productos));
        }
Example #15
0
 public JsonResult ParseaTodoAMayusculas()
 {
     ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
     foreach (var Producto in ClsProductos.getList())
     {
         Producto.NombreDeProducto = Producto.NombreDeProducto.Trim().ToUpper();
         Producto.Descripcion      = Producto.Descripcion.Trim().ToUpper();
         if (!Producto.Update())
         {
             Resultado.Resultado = false;
             Resultado.Mensaje   = "Ocurrio un error al hacer ToUpperCase";
         }
     }
     return(Json(Resultado, JsonRequestBehavior.AllowGet));
 }
Example #16
0
 private ClsAdicional.ClsResultado ValidaNombreDeProducto(String NombreDeProducto, int row, ref Dictionary <String, String> Registros, ref List <ClsProductos> NombresYCodigoDeBarras)
 {
     ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
     if (!String.IsNullOrEmpty(NombreDeProducto))
     {
         List <ClsProductos> Producto = ClsProductos.getList("NombreDeProducto.Trim().ToUpper() == \"" + NombreDeProducto.Trim().ToUpper() + "\" && CveDeEstatus == 1");
         if (Producto.Count() == 0)
         {
             if ((from q in NombresYCodigoDeBarras where q.NombreDeProducto.Trim().ToUpper() == NombreDeProducto.Trim().ToUpper() select q.NombreDeProducto).Count() == 0)
             {
                 Registros.Add("NombreDeProducto", NombreDeProducto.Trim().ToUpper());
                 String CodigoDeBarras = Registros["CodigoDeBarras"].ToString();
                 if (NombresYCodigoDeBarras.Count() == 0)
                 {
                     NombresYCodigoDeBarras.Add(new ClsProductos()
                     {
                         CodigoDeBarras = CodigoDeBarras, NombreDeProducto = NombreDeProducto.Trim().ToUpper()
                     });
                 }
                 else
                 {
                     NombresYCodigoDeBarras.Find(x => x.CodigoDeBarras == CodigoDeBarras).NombreDeProducto = NombreDeProducto.Trim().ToUpper();
                 }
             }
             else
             {
                 Resultado.Resultado = false;
                 Resultado.Mensaje   = "El campo Nombre de Producto a registrar se encuetra en un registro previo dentro del archivo";
                 Registros.Add("NombreDeProducto", NombreDeProducto.Trim().ToUpper());
             }
         }
         else
         {
             Resultado.Resultado = false;
             Resultado.Mensaje   = "El campo Nombre de Producto a registrar se encuetra en un registro previo dentro del sistema";
             Registros.Add("NombreDeProducto", NombreDeProducto.Trim().ToUpper());
         }
     }
     else
     {
         Resultado.Resultado = false;
         Resultado.Mensaje   = "El campo codigo de Nombre de Producto es requerido";
         Registros.Add("NombreDeProducto", String.Empty);
     }
     return(Resultado);
 }
Example #17
0
        public JsonResult CargaProducto(String NombreOCodigoDeProducto, short NumeroDeProducto = 0)
        {
            List <ClsProductos>         Productos = new List <ClsProductos>();
            List <ClsConfiguraPaquetes> Paquetes  = new List <ClsConfiguraPaquetes>();
            ClsProductos Producto = new ClsProductos();

            ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
            String Filtro = String.Empty;

            if (NumeroDeProducto == 0)
            {
                Filtro    = String.Format("CodigoDeBarras == \"{0}\" && CveDeEstatus == {1}", NombreOCodigoDeProducto, (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO);
                Productos = ClsProductos.getList(Filtro);
                if (Productos.Count == 0)
                {
                    Filtro    = String.Format("NombreDeProducto == \"{0}\" && CveDeEstatus == {1}", NombreOCodigoDeProducto, (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO);
                    Productos = ClsProductos.getList(Filtro);
                }
            }
            else
            {
                Filtro    = String.Format("NumeroDeProducto == {0} && CveDeEstatus == {1}", NumeroDeProducto, (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO);
                Productos = ClsProductos.getList(Filtro);
            }

            if (Productos.Count != 0)
            {
                Producto = Productos.FirstOrDefault();
                Filtro   = String.Format("NumeroDeProductoPadre == {0}", Producto.NumeroDeProducto);
                Paquetes = ClsConfiguraPaquetes.getList(Filtro);
                if (Paquetes.Count() == 0)
                {
                    Filtro   = String.Format("NumeroDeProductoHijo == {0}", Producto.NumeroDeProducto);
                    Paquetes = ClsConfiguraPaquetes.getList(Filtro);
                }
            }
            else
            {
                Resultado.Resultado = false;
                Resultado.Mensaje   = "No fue posible encontrar el producto a registrar";
            }
            return(Json(new { Resultado, Producto, TienePaquetes = Paquetes.Count() != 0, Paquetes, Productos }, JsonRequestBehavior.AllowGet));
        }
Example #18
0
 public JsonResult AsignaMarcaMasivo()
 {
     foreach (var TipoProducto in ClsTiposDeProductos.getList())
     {
         List <short?> ListaMarcas = (from q in ClsProductos.getList("NumeroDeTipoDeProducto == " + TipoProducto.NumeroDeTipoDeProducto.ToString()) where q.NumeroDeMarca != 0 select q.NumeroDeMarca).Distinct().ToList();
         foreach (var Marca in ListaMarcas)
         {
             ClsAsignaMarcas AsignaMarcaAtipoProducto = new ClsAsignaMarcas()
             {
                 NumeroDeTipoDeProducto = TipoProducto.NumeroDeTipoDeProducto,
                 NumeroDeMarca          = (short)Marca
             };
             if (!AsignaMarcaAtipoProducto.Insert())
             {
                 return(Json(new { NumeroDeMarca = Marca }, JsonRequestBehavior.AllowGet));
             }
         }
     }
     return(Json(new { Resultado = "Correcto" }, JsonRequestBehavior.AllowGet));
 }
Example #19
0
 private ClsAdicional.ClsResultado ValidaCodigoDeBarras(String CodigoDeBarras, int row, ref Dictionary <String, String> Registros, ref List <ClsProductos> NombresYCodigoDeBarras)
 {
     ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
     if (!String.IsNullOrEmpty(CodigoDeBarras))
     {
         if ((from q in ClsProductos.getList() where q.CodigoDeBarras.Trim() == CodigoDeBarras.Trim() select q.CodigoDeBarras).Count() == 0)
         {
             if ((from q in NombresYCodigoDeBarras where q.CodigoDeBarras == CodigoDeBarras select q.CodigoDeBarras).Count() == 0)
             {
                 Registros.Add("CodigoDeBarras", CodigoDeBarras);
                 NombresYCodigoDeBarras.Add(new ClsProductos()
                 {
                     CodigoDeBarras = CodigoDeBarras, NombreDeProducto = String.Empty
                 });
             }
             else
             {
                 Resultado.Resultado = false;
                 Resultado.Mensaje   = "El campo codigo de barras a registrar se encuetra en un registro previo dentro del archivo";
                 Registros.Add("CodigoDeBarras", CodigoDeBarras);
             }
         }
         else
         {
             Resultado.Resultado = false;
             Resultado.Mensaje   = "El campo codigo de barras a registrar se encuetra en un registro previo dentro del sistema";
             Registros.Add("CodigoDeBarras", CodigoDeBarras);
         }
     }
     else
     {
         Resultado.Resultado = true;
         Resultado.Mensaje   = "El campo codigo de barras sera generado por el Sistema";
         Registros.Add("CodigoDeBarras", String.Empty);
     }
     return(Resultado);
 }
Example #20
0
        public ActionResult Edita(ProductoModel RegistroCapturado)
        {
            if (!ValidaSesion())
            {
                return(RedirectToAction("LoginOut", "Account"));
            }
            if (!ValidaFuncionalidad(NumeroDePantalla, (byte)ClsEnumerables.Funcionalidades.EDITA))
            {
                return(RedirectToAction("Detalle", "Producto", new { RegistroCapturado.fNumeroDeProducto }));
            }
            ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, "Producto actualizado de forma correcta");
            String Filtro = String.Empty;

            Filtro = String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\"", RegistroCapturado.NumeroDeProducto, RegistroCapturado.CodigoDeBarras);
            ProductoModel productos = (ProductoModel)(from q in ClsProductos.getList(Filtro)
                                                      select new ProductoModel()
            {
                NumeroDeProducto = q.NumeroDeProducto,
                CodigoDeBarras = q.CodigoDeBarras,
                FechaDeRegistro = q.FechaDeRegistro,
                CantidadDeProductoUltima = q.CantidadDeProductoUltima,
                CantidadDeProductoNueva = q.CantidadDeProductoNueva,
                CantidadDeProductoTotal = q.CantidadDeProductoTotal,
                NombreDeProducto = q.NombreDeProducto,
                Descripcion = q.Descripcion,
                NumeroDeTipoDeProducto = q.NumeroDeTipoDeProducto,
                NumeroDeMarca = q.NumeroDeMarca,
                CveAviso = q.CveAviso,
                CveCorreoSurtido = q.CveCorreoSurtido,
                CantidadMinima = q.CantidadMinima,
                NumeroDeProveedor = q.NumeroDeProveedor,
                PrecioUnitario = q.PrecioUnitario,
                CveDeEstatus = q.CveDeEstatus,
                NombreDeTipoDeProducto = q.NombreDeTipoDeProducto,
                NombreDeMarca = q.NombreDeMarca,
                TextoAviso = q.TextoAviso,
                TextoCorreoSurtido = q.TextoCorreoSurtido,
                NombreDeProveedor = q.NombreDeProveedor,
                TextoDeEstatus = q.TextoDeEstatus
            }).FirstOrDefault();

            if (RegistroCapturado.fCveAviso == 2)
            {
                ModelState.Remove("fCveCorreoSurtido");
                RegistroCapturado.fCveCorreoSurtido = 2;
                ModelState.Remove("fCantidadMinima");
                RegistroCapturado.fCantidadMinima = 0;
                ModelState.Remove("fNumeroDeProveedor");
                RegistroCapturado.fNumeroDeProveedor = 0;
            }
            if (ModelState.IsValid)
            {
                productos.NombreDeProducto       = RegistroCapturado.NombreDeProducto;
                productos.Descripcion            = RegistroCapturado.Descripcion;
                productos.NumeroDeTipoDeProducto = RegistroCapturado.NumeroDeTipoDeProducto;
                productos.NumeroDeMarca          = RegistroCapturado.NumeroDeMarca;
                productos.PrecioUnitario         = RegistroCapturado.PrecioUnitario;
                productos.CveAviso         = RegistroCapturado.CveAviso;
                productos.CveCorreoSurtido = RegistroCapturado.CveCorreoSurtido;
                productos.CantidadMinima   = RegistroCapturado.CantidadMinima;
                if (!productos.Update())
                {
                    Resultado.Resultado = false;
                    Resultado.Mensaje   = "Ocurrio un problema al actualizar el reigstro";
                }
                else
                {
                    ClsSequence Sequence = new ClsSequence((new DBKuupEntities()).Database);
                    ClsAudit    Audit    = Nucleo.Clases.ClsAuditInsert.RegistraAudit(Sequence.SQ_FolioAudit(), "EDITA");
                    productos.InsertAudit(Audit);
                }
            }
            else
            {
                Resultado.Resultado = false;
                Resultado.Mensaje   = "Campos incorrectos";
            }
            if (!Resultado.Resultado)
            {
                this.CargaCombos(RegistroCapturado);
                TempData["Resultado"] = Resultado.MensajeController();
                return(View(RegistroCapturado));
            }
            return(RedirectToAction("Detalle", "Producto", new { RegistroCapturado.NumeroDeProducto }));
        }
Example #21
0
 private void BotonTerminado_Click(object sender, EventArgs e)
 {
     ClsProductos objProduto = new ClsProductos();
     objProduto.EliminarProyecto();
     MessageBox.Show("Registro eliminado");
 }
Example #22
0
 private void ListarProyectos()
 {
     ClsProductos objProduto = new ClsProductos();
     dataGridView1 = objPro.ListarProyecto_M();
 }
Example #23
0
        public JsonResult UrlPreciosActualizados(String Precios)
        {
            ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, "Precios Actualizados");
            if (!ValidaSesion())
            {
                return(Json(new { UrlAccount = Url.Action("LoginOut", "Account") }, JsonRequestBehavior.AllowGet));
            }
            if (!ValidaFuncionalidad(NumeroDePantalla, (byte)ClsEnumerables.Funcionalidades.ALTA))
            {
                return(Json(new { UrlFun = Url.Action("Index", "VentaTotal") }, JsonRequestBehavior.AllowGet));
            }
            List <String> Datos = Precios.Split(':').ToList();

            foreach (var Dato in Datos)
            {
                List <String> Elementos = new List <string>();
                if (Dato.Contains("PrecioUnitario"))
                {
                    Elementos = Dato.Split('&').ToList();
                    ClsProductos Producto = (from q in ClsProductos.getList()
                                             where q.NumeroDeProducto == ClsAdicional.Convert <short>(Elementos[0].Split('=')[1])
                                             select q).FirstOrDefault();
                    if (Producto != null)
                    {
                        Producto.PrecioUnitario = ClsAdicional.Convert <decimal>(Elementos[1].Split('=')[1]);
                    }
                    if (!Producto.Update())
                    {
                        Resultado.Resultado = false;
                        Resultado.Mensaje   = "Ocurrio un error al actualizar el precio unitario del Producto";
                        break;
                    }
                    else
                    {
                        ClsSequence Sequence = new ClsSequence((new DBKuupEntities()).Database);
                        ClsAudit    Audit    = Nucleo.Clases.ClsAuditInsert.RegistraAudit(Sequence.SQ_FolioAudit(), "ACTUALIZAPRECIO");
                        Producto.InsertAudit(Audit);
                    }
                }
                else if (Dato.Contains("NumeroDeMayoreo"))
                {
                    Elementos = Dato.Split('&').ToList();
                    ClsConfiguraMayoreos ConfiguraMayoreo = (from q in ClsConfiguraMayoreos.getList()
                                                             where q.NumeroDeProducto == ClsAdicional.Convert <short>(Elementos[0].Split('=')[1]) &&
                                                             q.NumeroDeMayoreo == ClsAdicional.Convert <short>(Elementos[1].Split('=')[1])
                                                             select q).FirstOrDefault();
                    if (ConfiguraMayoreo != null)
                    {
                        ConfiguraMayoreo.PrecioDeMayoreo = ClsAdicional.Convert <decimal>(Elementos[2].Split('=')[1]);
                        if (!ConfiguraMayoreo.Update())
                        {
                            Resultado.Resultado = false;
                            Resultado.Mensaje   = "Ocurrio un error al actualizar el precio de mayoreo";
                            break;
                        }
                        else
                        {
                            ClsSequence Sequence = new ClsSequence((new DBKuupEntities()).Database);
                            ClsAudit    Audit    = Nucleo.Clases.ClsAuditInsert.RegistraAudit(Sequence.SQ_FolioAudit(), "ACTUALIZAPRECIO");
                            ConfiguraMayoreo.InsertAudit(Audit);
                        }
                    }
                }
                else if (Dato.Contains("PrecioDeProductoPadre") || Dato.Contains("PrecioDeProductoHijo"))
                {
                    Elementos = Dato.Split('&').ToList();
                    ClsConfiguraPaquetes ConfiguraPaquetes = (from q in ClsConfiguraPaquetes.getList()
                                                              where q.NumeroDeProductoPadre == ClsAdicional.Convert <short>(Elementos[0].Split('=')[1]) &&
                                                              q.NumeroDeProductoHijo == ClsAdicional.Convert <short>(Elementos[1].Split('=')[1])
                                                              select q).FirstOrDefault();
                    if (ConfiguraPaquetes != null)
                    {
                        if (Dato.Contains("PrecioDeProductoPadre"))
                        {
                            ConfiguraPaquetes.PrecioDeProductoPadre = ClsAdicional.Convert <decimal>(Elementos[2].Split('=')[1]);
                        }
                        else if (Dato.Contains("PrecioDeProductoHijo"))
                        {
                            ConfiguraPaquetes.PrecioDeProductoHijo = ClsAdicional.Convert <decimal>(Elementos[2].Split('=')[1]);
                        }
                        if (!ConfiguraPaquetes.Update())
                        {
                            Resultado.Resultado = false;
                            Resultado.Mensaje   = "Ocurrio un error al actualizar el precio de paquetes";
                            break;
                        }
                        else
                        {
                            ClsSequence Sequence = new ClsSequence((new DBKuupEntities()).Database);
                            ClsAudit    Audit    = Nucleo.Clases.ClsAuditInsert.RegistraAudit(Sequence.SQ_FolioAudit(), "ACTUALIZAPRECIO");
                            ConfiguraPaquetes.InsertAudit(Audit);
                        }
                    }
                }
            }
            return(Json(Resultado, JsonRequestBehavior.AllowGet));
        }
Example #24
0
        public JsonResult ProductoParaTablaV2(short NumeroDeProducto, short Cantidad, String Paquetes, String RegistrosPrevios)
        {
            List <ClsVentas> RegistrosPrev = ClsAdicional.Deserializar <List <ClsVentas> >(RegistrosPrevios);

            if (RegistrosPrev == null)
            {
                RegistrosPrev = new List <ClsVentas>();
            }
            List <ClsVentas>            Registro      = new List <ClsVentas>();
            List <ClsConfiguraPaquetes> ListaPaquetes = new List <ClsConfiguraPaquetes>();
            String Filtro       = String.Empty;
            short  CantidadFija = Cantidad;

            if (!String.IsNullOrEmpty(Paquetes))
            {
                Filtro        = String.Format("NumeroDeProductoPadre == {0} && NumeroDeProductoHijo == {1}", ClsAdicional.Convert <short>(Paquetes.Split('_')[0]), ClsAdicional.Convert <short>(Paquetes.Split('_')[1]));
                ListaPaquetes = ClsConfiguraPaquetes.getList(Filtro);
                if (ListaPaquetes.Count() == 1)
                {
                    if (RegistrosPrev.Exists(x => x.NumeroDeProducto == ListaPaquetes.FirstOrDefault().NumeroDeProductoPadre))
                    {
                        CantidadFija = (short)(CantidadFija + RegistrosPrev.FindAll(x => x.NumeroDeProducto == ListaPaquetes.FirstOrDefault().NumeroDeProductoPadre).FirstOrDefault().CantidadDeProducto);
                    }
                    ClsProductos Producto            = ClsProductos.getList("NumeroDeProducto == " + ListaPaquetes.FirstOrDefault().NumeroDeProductoPadre.ToString() + " && CodigoDeBarras == \"" + ListaPaquetes.FirstOrDefault().CodigoDeBarrasPadre + "\" && CveDeEstatus == " + (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO).FirstOrDefault();
                    decimal      PrecioUnitario      = ListaPaquetes.FirstOrDefault().PrecioDeProductoPadre;
                    short        CantidadParaMayoreo = CantidadFija;
                    if (RegistrosPrev.Exists(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                    {
                        CantidadParaMayoreo = (short)(RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca).Sum(y => y.CantidadDeProducto) + CantidadFija);
                    }
                    Filtro = String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\" && CantidadMinima <= {2} && CantidadMaxima >= {2}", ListaPaquetes.FirstOrDefault().NumeroDeProductoPadre, ListaPaquetes.FirstOrDefault().CodigoDeBarrasPadre, CantidadParaMayoreo);
                    List <ClsConfiguraMayoreos> Mayoreo = ClsConfiguraMayoreos.getList(Filtro);
                    bool EsMayoreo = false;
                    if (Mayoreo.Count() != 0)
                    {
                        PrecioUnitario = Mayoreo.FirstOrDefault().PrecioDeMayoreo;
                        EsMayoreo      = true;
                    }
                    if (RegistrosPrev.Exists(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                    {
                        foreach (ClsVentas venta in RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                        {
                            Registro.Add(new ClsVentas()
                            {
                                NumeroDeProducto       = venta.NumeroDeProducto,
                                CodigoDeBarras         = venta.CodigoDeBarras,
                                NumeroDeTipoDeProducto = venta.NumeroDeTipoDeProducto,
                                NumeroDeMarca          = venta.NumeroDeMarca,
                                CantidadDeProducto     = venta.CantidadDeProducto,
                                ImporteDeProducto      = Math.Round(venta.CantidadDeProducto * (EsMayoreo ? PrecioUnitario : venta.PrecioUnitario), 2),
                                PrecioUnitario         = (EsMayoreo ? PrecioUnitario : venta.PrecioUnitario),
                                NombreDeProducto       = venta.NombreDeProducto
                            });
                        }
                    }
                    Registro.Add(new ClsVentas()
                    {
                        NumeroDeProducto       = ListaPaquetes.FirstOrDefault().NumeroDeProductoPadre,
                        CodigoDeBarras         = ListaPaquetes.FirstOrDefault().CodigoDeBarrasPadre,
                        NumeroDeTipoDeProducto = Producto.NumeroDeTipoDeProducto,
                        NumeroDeMarca          = Producto.NumeroDeMarca,
                        CantidadDeProducto     = CantidadFija,
                        ImporteDeProducto      = Math.Round(CantidadFija * PrecioUnitario, 2),
                        PrecioUnitario         = PrecioUnitario,
                        NombreDeProducto       = ListaPaquetes.FirstOrDefault().NombreDeProductoPadre
                    });
                    CantidadFija = Cantidad;
                    if (RegistrosPrev.Exists(x => x.NumeroDeProducto == ListaPaquetes.FirstOrDefault().NumeroDeProductoHijo))
                    {
                        CantidadFija = (short)(CantidadFija + RegistrosPrev.FindAll(x => x.NumeroDeProducto == ListaPaquetes.FirstOrDefault().NumeroDeProductoHijo).FirstOrDefault().CantidadDeProducto);
                    }
                    Producto            = ClsProductos.getList("NumeroDeProducto == " + ListaPaquetes.FirstOrDefault().NumeroDeProductoHijo.ToString() + " && CodigoDeBarras == \"" + ListaPaquetes.FirstOrDefault().CodigoDeBarrasHijo + "\" && CveDeEstatus == " + (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO).FirstOrDefault();
                    PrecioUnitario      = (decimal)ListaPaquetes.FirstOrDefault().PrecioDeProductoHijo;
                    CantidadParaMayoreo = CantidadFija;
                    if (RegistrosPrev.Exists(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                    {
                        CantidadParaMayoreo = (short)(RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca).Sum(y => y.CantidadDeProducto) + CantidadFija);
                    }
                    Filtro    = String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\" && CantidadMinima <= {2} && CantidadMaxima >= {2}", ListaPaquetes.FirstOrDefault().NumeroDeProductoHijo, ListaPaquetes.FirstOrDefault().CodigoDeBarrasHijo, CantidadParaMayoreo);
                    Mayoreo   = ClsConfiguraMayoreos.getList(Filtro);
                    EsMayoreo = false;
                    if (Mayoreo.Count() != 0)
                    {
                        PrecioUnitario = Mayoreo.FirstOrDefault().PrecioDeMayoreo;
                        EsMayoreo      = true;
                    }
                    if (RegistrosPrev.Exists(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                    {
                        foreach (ClsVentas venta in RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                        {
                            Registro.Add(new ClsVentas()
                            {
                                NumeroDeProducto       = venta.NumeroDeProducto,
                                CodigoDeBarras         = venta.CodigoDeBarras,
                                NumeroDeTipoDeProducto = venta.NumeroDeTipoDeProducto,
                                NumeroDeMarca          = venta.NumeroDeMarca,
                                CantidadDeProducto     = venta.CantidadDeProducto,
                                ImporteDeProducto      = Math.Round(venta.CantidadDeProducto * (EsMayoreo ? PrecioUnitario : venta.PrecioUnitario), 2),
                                PrecioUnitario         = (EsMayoreo ? PrecioUnitario : venta.PrecioUnitario),
                                NombreDeProducto       = venta.NombreDeProducto
                            });
                        }
                    }
                    Registro.Add(new ClsVentas()
                    {
                        NumeroDeProducto       = ListaPaquetes.FirstOrDefault().NumeroDeProductoHijo,
                        CodigoDeBarras         = ListaPaquetes.FirstOrDefault().CodigoDeBarrasHijo,
                        NumeroDeTipoDeProducto = Producto.NumeroDeTipoDeProducto,
                        NumeroDeMarca          = Producto.NumeroDeMarca,
                        CantidadDeProducto     = CantidadFija,
                        ImporteDeProducto      = Math.Round(CantidadFija * PrecioUnitario, 2),
                        PrecioUnitario         = PrecioUnitario,
                        NombreDeProducto       = ListaPaquetes.FirstOrDefault().NombreDeProductoHijo
                    });
                }
            }
            else
            {
                CantidadFija = Cantidad;
                if (RegistrosPrev.Exists(x => x.NumeroDeProducto == NumeroDeProducto))
                {
                    CantidadFija = (short)(CantidadFija + RegistrosPrev.FindAll(x => x.NumeroDeProducto == NumeroDeProducto).FirstOrDefault().CantidadDeProducto);
                }
                ClsProductos Producto            = ClsProductos.getList("NumeroDeProducto == " + NumeroDeProducto.ToString() + " && CveDeEstatus == " + (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO).FirstOrDefault();
                decimal      PrecioUnitario      = Producto.PrecioUnitario;
                short        CantidadParaMayoreo = CantidadFija;
                if (RegistrosPrev.Exists(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != NumeroDeProducto))
                {
                    CantidadParaMayoreo = (short)(RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca).Sum(y => y.CantidadDeProducto) + CantidadFija);
                }
                Filtro = String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\" && CantidadMinima <= {2} && CantidadMaxima >= {2}", Producto.NumeroDeProducto, Producto.CodigoDeBarras, CantidadParaMayoreo);
                List <ClsConfiguraMayoreos> Mayoreo = ClsConfiguraMayoreos.getList(Filtro);
                bool EsMayoreo = false;
                if (Mayoreo.Count() != 0)
                {
                    PrecioUnitario = Mayoreo.FirstOrDefault().PrecioDeMayoreo;
                    EsMayoreo      = true;
                }
                if (RegistrosPrev.Exists(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                {
                    foreach (ClsVentas venta in RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == Producto.NumeroDeTipoDeProducto && x.NumeroDeMarca == Producto.NumeroDeMarca && x.NumeroDeProducto != Producto.NumeroDeProducto))
                    {
                        Registro.Add(new ClsVentas()
                        {
                            NumeroDeProducto       = venta.NumeroDeProducto,
                            CodigoDeBarras         = venta.CodigoDeBarras,
                            NumeroDeTipoDeProducto = venta.NumeroDeTipoDeProducto,
                            NumeroDeMarca          = venta.NumeroDeMarca,
                            CantidadDeProducto     = venta.CantidadDeProducto,
                            ImporteDeProducto      = Math.Round(venta.CantidadDeProducto * (EsMayoreo ? PrecioUnitario : venta.PrecioUnitario), 2),
                            PrecioUnitario         = (EsMayoreo ? PrecioUnitario : venta.PrecioUnitario),
                            NombreDeProducto       = venta.NombreDeProducto
                        });
                    }
                }
                Registro.Add(new ClsVentas()
                {
                    NumeroDeProducto       = Producto.NumeroDeProducto,
                    CodigoDeBarras         = Producto.CodigoDeBarras,
                    NumeroDeTipoDeProducto = Producto.NumeroDeTipoDeProducto,
                    NumeroDeMarca          = Producto.NumeroDeMarca,
                    CantidadDeProducto     = CantidadFija,
                    ImporteDeProducto      = Math.Round(CantidadFija * PrecioUnitario, 2),
                    PrecioUnitario         = PrecioUnitario,
                    NombreDeProducto       = Producto.NombreDeProducto
                });
            }
            return(Json(new { Registro }, JsonRequestBehavior.AllowGet));
        }
Example #25
0
        public JsonResult DeleteDeProducto(String RegistroPrevio, String RegistrosPrevios)
        {
            List <ClsVentas>            Registro      = new List <ClsVentas>();
            ClsVentas                   RegistroPrev  = ClsAdicional.Deserializar <ClsVentas>(RegistroPrevio);
            List <ClsVentas>            RegistrosPrev = ClsAdicional.Deserializar <List <ClsVentas> >(RegistrosPrevios);
            List <ClsConfiguraPaquetes> Paquete       = new List <ClsConfiguraPaquetes>();
            String Filtro = String.Empty;
            bool   EsHijo = false;

            if (RegistrosPrev.FindAll(x => x.NumeroDeProducto != RegistroPrev.NumeroDeProducto).Count() != 0)
            {
                foreach (var item in RegistrosPrev.FindAll(x => x.NumeroDeProducto != RegistroPrev.NumeroDeProducto))
                {
                    Filtro = String.Format("NumeroDeProductoPadre == {0} && NumeroDeProductoHijo == {1}", RegistroPrev.NumeroDeProducto, item.NumeroDeProducto);
                    var Encontrado = ClsConfiguraPaquetes.getList(Filtro);
                    if (Encontrado.Count() != 0)
                    {
                        Paquete.AddRange(Encontrado);
                    }
                    else
                    {
                        Filtro     = String.Format("NumeroDeProductoPadre == {0} && NumeroDeProductoHijo == {1}", item.NumeroDeProducto, RegistroPrev.NumeroDeProducto);
                        Encontrado = ClsConfiguraPaquetes.getList(Filtro);
                        if (Encontrado.Count() != 0)
                        {
                            EsHijo = true;
                            Paquete.AddRange(Encontrado);
                        }
                    }
                }
            }
            if (Paquete.Count() != 0)
            {
                Registro.Add(new ClsVentas()
                {
                    NumeroDeProducto       = RegistroPrev.NumeroDeProducto,
                    CodigoDeBarras         = RegistroPrev.CodigoDeBarras,
                    NumeroDeTipoDeProducto = RegistroPrev.NumeroDeTipoDeProducto,
                    NumeroDeMarca          = RegistroPrev.NumeroDeMarca,
                    CantidadDeProducto     = 0,
                    ImporteDeProducto      = 0,
                    PrecioUnitario         = 0,
                    NombreDeProducto       = RegistroPrev.NombreDeProducto
                });
                short Cantidad = RegistroPrev.CantidadDeProducto;
                foreach (var pac in Paquete)
                {
                    var Item = RegistrosPrev.Find(x => x.NumeroDeProducto == pac.NumeroDeProductoHijo);
                    if (EsHijo)
                    {
                        Item = RegistrosPrev.Find(x => x.NumeroDeProducto == pac.NumeroDeProductoPadre);
                    }
                    if (Cantidad > Item.CantidadDeProducto)
                    {
                        Cantidad = (short)(Cantidad - Item.CantidadDeProducto);
                        Registro.Add(new ClsVentas()
                        {
                            NumeroDeProducto       = Item.NumeroDeProducto,
                            CodigoDeBarras         = Item.CodigoDeBarras,
                            NumeroDeTipoDeProducto = Item.NumeroDeTipoDeProducto,
                            NumeroDeMarca          = Item.NumeroDeMarca,
                            CantidadDeProducto     = 0,
                            ImporteDeProducto      = 0,
                            PrecioUnitario         = 0,
                            NombreDeProducto       = Item.NombreDeProducto
                        });
                    }
                    else if (Cantidad < Item.CantidadDeProducto)
                    {
                        Registro.Add(new ClsVentas()
                        {
                            NumeroDeProducto       = Item.NumeroDeProducto,
                            CodigoDeBarras         = Item.CodigoDeBarras,
                            NumeroDeTipoDeProducto = Item.NumeroDeTipoDeProducto,
                            NumeroDeMarca          = Item.NumeroDeMarca,
                            CantidadDeProducto     = (short)(Item.CantidadDeProducto - Cantidad),
                            ImporteDeProducto      = 0,
                            PrecioUnitario         = 0,
                            NombreDeProducto       = Item.NombreDeProducto
                        });
                        Cantidad = 0;
                    }
                    else
                    {
                        Registro.Add(new ClsVentas()
                        {
                            NumeroDeProducto       = Item.NumeroDeProducto,
                            CodigoDeBarras         = Item.CodigoDeBarras,
                            NumeroDeTipoDeProducto = Item.NumeroDeTipoDeProducto,
                            NumeroDeMarca          = Item.NumeroDeMarca,
                            CantidadDeProducto     = 0,
                            ImporteDeProducto      = 0,
                            PrecioUnitario         = 0,
                            NombreDeProducto       = Item.NombreDeProducto
                        });
                        Cantidad = 0;
                    }
                }
            }
            else
            {
                Registro.Add(new ClsVentas()
                {
                    NumeroDeProducto       = RegistroPrev.NumeroDeProducto,
                    CodigoDeBarras         = RegistroPrev.CodigoDeBarras,
                    NumeroDeTipoDeProducto = RegistroPrev.NumeroDeTipoDeProducto,
                    NumeroDeMarca          = RegistroPrev.NumeroDeMarca,
                    CantidadDeProducto     = 0,
                    ImporteDeProducto      = 0,
                    PrecioUnitario         = 0,
                    NombreDeProducto       = RegistroPrev.NombreDeProducto
                });
            }
            List <ClsVentas> RegistroTemp = new List <ClsVentas>();

            foreach (var reg in Registro)
            {
                if (RegistrosPrev.Exists(x => x.NumeroDeTipoDeProducto == reg.NumeroDeTipoDeProducto && x.NumeroDeMarca == reg.NumeroDeMarca && x.NumeroDeProducto != reg.NumeroDeProducto))
                {
                    List <ClsVentas>            RegistroImplicados = RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == reg.NumeroDeTipoDeProducto && x.NumeroDeMarca == reg.NumeroDeMarca && x.NumeroDeProducto != reg.NumeroDeProducto);
                    short                       CantidadMayore     = (short)(RegistroImplicados.Sum(x => x.CantidadDeProducto) + reg.CantidadDeProducto);
                    List <ClsConfiguraMayoreos> Mayoreos           = ClsConfiguraMayoreos.getList(String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\" && CantidadMinima <= {2} && CantidadMaxima >= {2}", reg.NumeroDeProducto, reg.CodigoDeBarras, CantidadMayore));
                    if (Mayoreos.Count() != 0)
                    {
                        if (Mayoreos.FirstOrDefault().PrecioDeMayoreo != RegistroImplicados.FirstOrDefault().PrecioUnitario)
                        {
                            foreach (var item in RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == reg.NumeroDeTipoDeProducto && x.NumeroDeMarca == reg.NumeroDeMarca && x.NumeroDeProducto != reg.NumeroDeProducto))
                            {
                                if (!Registro.Exists(x => x.NumeroDeProducto == item.NumeroDeProducto))
                                {
                                    RegistroTemp.Add(new ClsVentas()
                                    {
                                        NumeroDeProducto       = item.NumeroDeProducto,
                                        CodigoDeBarras         = item.CodigoDeBarras,
                                        NumeroDeTipoDeProducto = item.NumeroDeTipoDeProducto,
                                        NumeroDeMarca          = item.NumeroDeMarca,
                                        CantidadDeProducto     = item.CantidadDeProducto,
                                        ImporteDeProducto      = Math.Round(item.CantidadDeProducto * Mayoreos.FirstOrDefault().PrecioDeMayoreo, 2),
                                        PrecioUnitario         = Mayoreos.FirstOrDefault().PrecioDeMayoreo,
                                        NombreDeProducto       = item.NombreDeProducto
                                    });
                                }
                                else
                                {
                                    var previo = Registro.Find(x => x.NumeroDeProducto == item.NumeroDeProducto);
                                    if (previo.CantidadDeProducto != 0)
                                    {
                                        previo.PrecioUnitario    = Mayoreos.FirstOrDefault().PrecioDeMayoreo;
                                        previo.ImporteDeProducto = Math.Round(reg.CantidadDeProducto * reg.PrecioUnitario, 2);
                                    }
                                }
                            }
                            if (reg.CantidadDeProducto != 0)
                            {
                                reg.PrecioUnitario    = Mayoreos.FirstOrDefault().PrecioDeMayoreo;
                                reg.ImporteDeProducto = Math.Round(reg.CantidadDeProducto * reg.PrecioUnitario, 2);
                            }
                        }
                    }
                    else
                    {
                        foreach (var item in RegistrosPrev.FindAll(x => x.NumeroDeTipoDeProducto == reg.NumeroDeTipoDeProducto && x.NumeroDeMarca == reg.NumeroDeMarca && x.NumeroDeProducto != reg.NumeroDeProducto))
                        {
                            if (!Registro.Exists(x => x.NumeroDeProducto == item.NumeroDeProducto))
                            {
                                ClsProductos producto = ClsProductos.getList("NumeroDeProducto == " + item.NumeroDeProducto + " && CodigoDeBarras == \"" + item.CodigoDeBarras + "\"").FirstOrDefault();
                                if (producto.PrecioUnitario != item.PrecioUnitario)
                                {
                                    RegistroTemp.Add(new ClsVentas()
                                    {
                                        NumeroDeProducto       = item.NumeroDeProducto,
                                        CodigoDeBarras         = item.CodigoDeBarras,
                                        NumeroDeTipoDeProducto = item.NumeroDeTipoDeProducto,
                                        NumeroDeMarca          = item.NumeroDeMarca,
                                        CantidadDeProducto     = item.CantidadDeProducto,
                                        ImporteDeProducto      = Math.Round(item.CantidadDeProducto * producto.PrecioUnitario, 2),
                                        PrecioUnitario         = producto.PrecioUnitario,
                                        NombreDeProducto       = item.NombreDeProducto
                                    });
                                }
                            }
                            else
                            {
                                var previo = Registro.Find(x => x.NumeroDeProducto == item.NumeroDeProducto);
                                if (previo.CantidadDeProducto != 0)
                                {
                                    ClsProductos producto = ClsProductos.getList("NumeroDeProducto == " + previo.NumeroDeProducto + " && CodigoDeBarras == \"" + previo.CodigoDeBarras + "\"").FirstOrDefault();
                                    previo.PrecioUnitario    = producto.PrecioUnitario;
                                    previo.ImporteDeProducto = Math.Round(previo.CantidadDeProducto * previo.PrecioUnitario, 2);
                                }
                            }
                        }
                        if (reg.CantidadDeProducto != 0)
                        {
                            ClsProductos producto = ClsProductos.getList("NumeroDeProducto == " + reg.NumeroDeProducto + " && CodigoDeBarras == \"" + reg.CodigoDeBarras + "\"").FirstOrDefault();
                            reg.PrecioUnitario    = producto.PrecioUnitario;
                            reg.ImporteDeProducto = Math.Round(reg.CantidadDeProducto * reg.PrecioUnitario, 2);
                        }
                    }
                }
            }
            Registro.AddRange(RegistroTemp);
            return(Json(new { Registro }, JsonRequestBehavior.AllowGet));
        }
Example #26
0
        private void ListarProductos()
        {
            ClsProductos objprod = new ClsProductos();

            dataGridView1.DataSource = objprod.ListarProductos();
        }
Example #27
0
        public ActionResult Baja(short NumeroDeProducto, String CodigoDeBarras)
        {
            if (!ValidaSesion())
            {
                return(RedirectToAction("LoginOut", "Account"));
            }
            if (!ValidaFuncionalidad(NumeroDePantalla, (byte)ClsEnumerables.Funcionalidades.BAJA))
            {
                return(RedirectToAction("Index", "Producto"));
            }
            ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado();
            var           ProductoClase         = ClsProductos.getList(String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\"", NumeroDeProducto, CodigoDeBarras));
            ProductoModel Producto = new ProductoModel(ProductoClase.FirstOrDefault());

            if (Producto == null)
            {
                Resultado.Resultado = false;
                Resultado.Mensaje   = "El producto no se encuentra o no cuenta con el estatus correcto";
            }
            else
            {
                List <ClsConfiguraMayoreos> Mayoreos = ClsConfiguraMayoreos.getList(String.Format("NumeroDeProducto == {0} && CodigoDeBarras == \"{1}\"", Producto.NumeroDeProducto, Producto.CodigoDeBarras));
                List <ClsConfiguraPaquetes> Paquetes = ClsConfiguraPaquetes.getList(String.Format("(NumeroDeProductoPadre == {0} && CodigoDeBarrasPadre == \"{1}\") || (NumeroDeProductoHijo == {0} && CodigoDeBarrasHijo == \"{1}\")", Producto.NumeroDeProducto, Producto.CodigoDeBarras));
                using (DBKuupEntities db = new DBKuupEntities())
                {
                    using (var Transaccion = db.Database.BeginTransaction())
                    {
                        try
                        {
                            if (Mayoreos.Count() != 0)
                            {
                                foreach (var item in Mayoreos)
                                {
                                    if (!item.Delete())
                                    {
                                        Transaccion.Rollback();
                                        Resultado.Resultado = false;
                                        Resultado.Mensaje   = "No fue posible realizar la baja de la configuracion de mayoreo asignada a este producto";
                                        return(Json(Resultado, JsonRequestBehavior.AllowGet));
                                    }
                                }
                            }
                            if (Paquetes.Count() != 0)
                            {
                                foreach (var item in Paquetes)
                                {
                                    if (!item.Delete())
                                    {
                                        Transaccion.Rollback();
                                        Resultado.Resultado = false;
                                        Resultado.Mensaje   = "No fue posible realizar la baja de los paquetes asignados al producto";
                                        return(Json(Resultado, JsonRequestBehavior.AllowGet));
                                    }
                                }
                            }
                            Producto.CveDeEstatus = 2;
                            if (!Producto.Update())
                            {
                                Resultado.Resultado = false;
                                Resultado.Mensaje   = "No fue posible realizar la baja del producto";
                                Transaccion.Rollback();
                            }
                            else
                            {
                                ClsSequence Sequence = new ClsSequence((new DBKuupEntities()).Database);
                                ClsAudit    Audit    = Nucleo.Clases.ClsAuditInsert.RegistraAudit(Sequence.SQ_FolioAudit(), "BAJA");
                                Producto.InsertAudit(Audit);
                                Resultado.Resultado = true;
                                Resultado.Mensaje   = "Baja correcto";
                                Transaccion.Commit();
                            }
                        }
                        catch (Exception e)
                        {
                            Transaccion.Rollback();
                            Resultado.Resultado = false;
                            Resultado.Mensaje   = Recursos.Textos.Bitacora_TextoTryCatchGenerico;
                            ClsBitacora.GeneraBitacora(NumeroDePantalla, 4, "Baja", String.Format(Recursos.Textos.Bitacora_TextoDeError, e.GetType().ToString(), e.Message.Trim(), e.GetHashCode().ToString()));
                        }
                    }
                }
            }
            return(Json(Resultado, JsonRequestBehavior.AllowGet));
        }
Example #28
0
 public ClsAdicional.ClsResultado InsertSurtidos(String JsonSurtido)
 {
     ClsAdicional.ClsResultado Resultado = new ClsAdicional.ClsResultado(true, String.Empty);
     if (!String.IsNullOrEmpty(JsonSurtido))
     {
         List <ClsSurtidos> Surtidos = ClsAdicional.Deserializar <List <ClsSurtidos> >(JsonSurtido);
         if (Surtidos == null)
         {
             Surtidos = new List <ClsSurtidos>();
         }
         if (Surtidos.Count() != 0)
         {
             using (DBKuupEntities db = new DBKuupEntities())
             {
                 using (var Transaccion = db.Database.BeginTransaction())
                 {
                     try
                     {
                         ClsSequence Sequence       = new ClsSequence(db.Database);
                         var         Productos      = ClsProductos.getList(listaProductos: Surtidos.Select(x => x.NumeroDeProducto).ToList());
                         var         ProductosAudit = (from q in db.ProductoAudit select q.PRO_NUM_PRODUCTO).Distinct().ToList();
                         short       FolioDeSurtido = Sequence.SQ_FolioSurtido();
                         foreach (var Surtido in Surtidos)
                         {
                             Surtido.db             = db;
                             Surtido.FolioDeSurtido = FolioDeSurtido;
                             Surtido.FechaDeSurtido = DateTime.Now;
                             if (!ManejaProveedor)
                             {
                                 Surtido.NumeroDeUsuario = MoSesion.NumeroDeUsuario;
                             }
                             Surtido.CveDeEstatus = (byte)ClsEnumerables.CveDeEstatusGeneral.ACTIVO;
                             if (!Surtido.Insert())
                             {
                                 Resultado.Resultado = false;
                                 break;
                             }
                             else
                             {
                                 if (Productos.Exists(x => x.NumeroDeProducto == Surtido.NumeroDeProducto && x.CodigoDeBarras == Surtido.CodigoDeBarras))
                                 {
                                     var Producto = Productos.Find(x => x.NumeroDeProducto == Surtido.NumeroDeProducto && x.CodigoDeBarras == Surtido.CodigoDeBarras);
                                     Producto.db = db;
                                     if (!ProductosAudit.Exists(x => x == Producto.NumeroDeProducto))
                                     {
                                         ClsAudit Audit = Clases.ClsAuditInsert.RegistraAudit(Sequence.SQ_FolioAudit(), "ALTA");
                                         Producto.InsertAudit(Audit);
                                     }
                                     Producto.CantidadDeProductoUltima = Producto.CantidadDeProductoTotal;
                                     Producto.CantidadDeProductoNueva  = Surtido.CantidadNueva;
                                     Producto.CantidadDeProductoTotal  = (short)(Surtido.CantidadPrevia + Surtido.CantidadNueva);
                                     if (!Producto.Update())
                                     {
                                         Resultado.Resultado = false;
                                         break;
                                     }
                                     else
                                     {
                                         ClsAudit AuditUp = Clases.ClsAuditInsert.RegistraAudit(Sequence.SQ_FolioAudit(), "SURTIDO");
                                         Producto.InsertAudit(AuditUp);
                                     }
                                 }
                             }
                         }
                         if (Resultado.Resultado)
                         {
                             Transaccion.Commit();
                             Resultado.Mensaje = "Surtido dado de alta correctamente";
                         }
                         else
                         {
                             Transaccion.Rollback();
                             Resultado.Mensaje = "Ocurrio un problema al registrar el surtido";
                         }
                     }
                     catch (Exception e)
                     {
                         Transaccion.Rollback();
                         Resultado.Resultado = false;
                         Resultado.Mensaje   = Recursos.Textos.Bitacora_TextoTryCatchGenerico;
                         ClsBitacora.GeneraBitacora(1, 1, "InsertSurtidos", String.Format(Recursos.Textos.Bitacora_TextoDeError, e.GetType().ToString(), e.Message.Trim(), e.GetHashCode().ToString()));
                     }
                 }
             }
         }
         else
         {
             Resultado.Resultado = false;
             Resultado.Mensaje   = "El objeto de surtido esta vacio";
         }
     }
     return(Resultado);
 }
Example #29
0
        public ClsAdicional.ClsResultado RegistroDeVenta(decimal ImporteEntregado, decimal ImporteCambio, String ObjetoVenta)
        {
            ClsAdicional.ClsResultado Resultado     = new ClsAdicional.ClsResultado(true, "Registro de Venta Correcto");
            List <Object>             AvisaCantidad = new List <Object>();
            String Filtro = String.Empty;

            if (!String.IsNullOrEmpty(ObjetoVenta))
            {
                List <ClsVentas> RegistrosDeVentas = ClsAdicional.Deserializar <List <ClsVentas> >(ObjetoVenta);
                if (RegistrosDeVentas == null)
                {
                    RegistrosDeVentas = new List <ClsVentas>();
                }
                using (DBKuupEntities db = new DBKuupEntities())
                {
                    using (var Transaccion = db.Database.BeginTransaction())
                    {
                        try
                        {
                            ClsSequence      Sequence      = new ClsSequence(db.Database);
                            ClsVentasTotales VentasTotales = new ClsVentasTotales();
                            VentasTotales.db = db;
                            VentasTotales.FolioDeOperacion   = Sequence.SQ_FolioVenta();
                            VentasTotales.FechaDeOperacion   = DateTime.Now;
                            VentasTotales.NumeroDeUsuario    = MoSesion.NumeroDeUsuario;
                            VentasTotales.NombreDeCliente    = String.Empty;
                            VentasTotales.CveAplicaDescuento = 2;
                            VentasTotales.CveDeEstatus       = (byte)ClsEnumerables.CveDeEstatusVentas.VENDIDA;
                            VentasTotales.ImporteBruto       = (from q in RegistrosDeVentas select q.ImporteDeProducto).Sum();
                            VentasTotales.ImporteNeto        = VentasTotales.ImporteBruto;
                            VentasTotales.ImporteEntregado   = ImporteEntregado;
                            VentasTotales.ImporteCambio      = ImporteCambio;
                            if (VentasTotales.Insert())
                            {
                                var Productos = ClsProductos.getList(listaProductos: (from q in RegistrosDeVentas select q.NumeroDeProducto).ToList());
                                foreach (var Ventas in RegistrosDeVentas)
                                {
                                    if (Resultado.Resultado)
                                    {
                                        Ventas.db = db;
                                        Ventas.FolioDeOperacion = VentasTotales.FolioDeOperacion;
                                        var Producto = (from q in Productos where q.NumeroDeProducto == Ventas.NumeroDeProducto select q).FirstOrDefault();
                                        if (Ventas.CantidadDeProducto <= Producto.CantidadDeProductoTotal)
                                        {
                                            if (Ventas.Insert())
                                            {
                                                if (Producto != null)
                                                {
                                                    var Cantidad = Producto.CantidadDeProductoTotal - Ventas.CantidadDeProducto;
                                                    if (Cantidad >= 0)
                                                    {
                                                        Producto.db = db;
                                                        Producto.CantidadDeProductoTotal = (short)(Producto.CantidadDeProductoTotal - Ventas.CantidadDeProducto);
                                                        if (!Producto.Update())
                                                        {
                                                            Resultado.Resultado = false;
                                                            Resultado.Mensaje   = "No fue posible actualizar los titulos disponibles";
                                                            break;
                                                        }
                                                        if (Producto.CveAviso == 1)
                                                        {
                                                            if (Cantidad <= Producto.CantidadMinima)
                                                            {
                                                                //AvisaCantidad.Add(String.Format("El producto {0} esta proximo a terminarce Cantidad Actual {1}", Producto.NombreDeProducto, Producto.CantidadDeProductoTotal));
                                                                AvisaCantidad.Add(String.Format("{0}-x mensaje en bitacora", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0') + "1".PadLeft(3, '0')));
                                                                ClsBitacora.GeneraBitacora(1, 1, String.Format("RegistroDeVenta-{0}", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0') + "1".PadLeft(3, '0')), String.Format("El producto {0} esta proximo a terminarce Cantidad Actual {1}", Producto.NombreDeProducto, Producto.CantidadDeProductoTotal));
                                                            }
                                                        }
                                                    }
                                                    else
                                                    {
                                                        Resultado.Resultado = false;
                                                        //Resultado.Mensaje = "Ocurrió un problema al realizar la venta, debido a que no existen productos con la cantidad necesaria para hacer la venta";
                                                        Resultado.Mensaje = String.Format("{0}-x mensaje en bitacora", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0'), "2".PadLeft(3, '0'));
                                                        //AvisaCantidad.Add(String.Format("El producto {0} no cuenta con la cantidad a vender Cantidad Actual: {1} Cantidad a Vender: {2}", Producto.NombreDeProducto, Producto.CantidadDeProductoTotal, Ventas.CantidadDeProducto));
                                                        AvisaCantidad.Add(String.Format("{0}-x mensaje en bitacora", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0') + "2".PadLeft(3, '0')));
                                                        ClsBitacora.GeneraBitacora(1, 1, String.Format("RegistroDeVenta-{0}", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0') + "2".PadLeft(3, '0')), String.Format("El producto {0} no cuenta con la cantidad a vender Cantidad Actual: {1} Cantidad a Vender: {2}", Producto.NombreDeProducto, Producto.CantidadDeProductoTotal, Ventas.CantidadDeProducto));
                                                        break;
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                Resultado.Resultado = false;
                                                Resultado.Mensaje   = "No fue posible cargar el detalle de la Venta";
                                                break;
                                            }
                                        }
                                        else
                                        {
                                            Resultado.Resultado = false;
                                            //Resultado.Mensaje = "Ocurrió un problema al realizar la venta, debido a que no existen productos con la cantidad necesaria para hacer la venta";
                                            Resultado.Mensaje = String.Format("{0}-x mensaje en bitacora", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0') + "3".PadLeft(3, '0'));
                                            //AvisaCantidad.Add(String.Format("El producto {0} no cuenta con la cantidad a vender Cantidad Actual: {1} Cantidad a Vender: {2}", Producto.NombreDeProducto, Producto.CantidadDeProductoTotal, Ventas.CantidadDeProducto));
                                            AvisaCantidad.Add(String.Format("{0}-x mensaje en bitacora", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0') + "3".PadLeft(3, '0')));
                                            ClsBitacora.GeneraBitacora(1, 1, String.Format("RegistroDeVenta-{0}", (new ClsVentasTotales()).NumeroDePantallaKuup.ToString().PadLeft(3, '0') + "3".PadLeft(3, '0')), String.Format("El producto {0} no cuenta con la cantidad a vender Cantidad Actual: {1} Cantidad a Vender: {2}", Producto.NombreDeProducto, Producto.CantidadDeProductoTotal, Ventas.CantidadDeProducto));
                                            break;
                                        }
                                    }
                                }
                            }
                            else
                            {
                                Resultado.Resultado = false;
                                Resultado.Mensaje   = "No fue posible realizar la Venta";
                            }
                            String Mensaje = String.Empty;
                            if (AvisaCantidad.Count() != 0)
                            {
                                Mensaje = String.Join("</ br>", AvisaCantidad);
                            }
                            if (Resultado.Resultado)
                            {
                                Transaccion.Commit();
                                ClsAdicional.ClsResultado RTicket = GeneraTicket(VentasTotales.FolioDeOperacion);
                                Resultado.Adicional = new { MensajeAviso = Mensaje, Ticket = RTicket.Adicional };
                            }
                            else
                            {
                                Object Ticket = null;
                                Transaccion.Rollback();
                                Resultado.Adicional = new { MensajeAviso = Mensaje, Ticket };
                            }
                        }
                        catch (Exception e)
                        {
                            Object Ticket = null;
                            Transaccion.Rollback();
                            Resultado.Adicional = new { MensajeAviso = String.Empty, Ticket };
                            Resultado.Resultado = false;
                            Resultado.Mensaje   = Recursos.Textos.Bitacora_TextoTryCatchGenerico;
                            ClsBitacora.GeneraBitacora(1, 1, "RegistroDeVenta", String.Format(Recursos.Textos.Bitacora_TextoDeError, e.GetType().ToString(), e.Message.Trim(), e.GetHashCode().ToString()));
                        }
                    }
                }
            }
            return(Resultado);
        }