public ActionResult CostoProducto(int productoId)
        {
            var producto = Uow.Productos.Obtener(productoId);
            if (producto == null)
            {
                producto = new Producto();
            }

            var costo = new ProveedorProducto()
            {
                Producto = producto,
                ProductoId = productoId,
                Identifier = Guid.NewGuid(),
            };

            return PartialView(costo);
        }
Ejemplo n.º 2
0
        public void Crear(Compra compra)
        {
            compra.Identifier = Guid.NewGuid();

            var factura = Uow.Facturas.Obtener(compra.FacturaId);

            Uow.Facturas.Modificar(factura);

            //Fix para prevenir gurdar la factura.
            compra.Factura = null;

            ////Agregar una trasaccion por cada compra producto.
            foreach (CompraProducto compraProd in compra.ComprasProductos)
            {
                compraProd.Identifier = Guid.NewGuid();
                compraProd.FechaUltimaModificacion = DateTime.Now;

                var stockTransaccion = new StockTransaccion
                                           {
                                               Identifier = Guid.NewGuid(),
                                               Cantidad = compraProd.Cantidad,
                                               StockTransaccionTipoId = 2, //Compra
                                               FechaUltimaModificacion = DateTime.Now
                                           };

                //Tipo = 2 / Compra. TODO: Map an enum.

                ////Obtengo la instancia de stock para la compra del producto
                Stock stock = Uow.Stocks.Obtener(s => s.MaxiKioscoId == factura.MaxiKioscoId && s.ProductoId == compraProd.ProductoId);
                if (stock == null)
                {
                    stock = new Stock
                                {
                                    Identifier = Guid.NewGuid(),
                                    MaxiKioscoId = factura.MaxiKioscoId,
                                    ProductoId = compraProd.ProductoId,
                                    OperacionCreacion = "Compra en web",
                                    FechaCreacion = DateTime.Now
                                };
                    Uow.Stocks.Agregar(stock);
                }

                stockTransaccion.Stock = stock;
                Uow.StockTransacciones.Agregar(stockTransaccion);

                ////Actualizar el costo del producto para el proveedor seleccionado.
                var proveedorProducto = Uow.ProveedorProductos
                    .Obtener(pp => pp.ProductoId == compraProd.ProductoId &&
                        pp.ProveedorId == factura.ProveedorId);

                //Si el producto no esta cargado para el proveedor debemos crearlo
                if (proveedorProducto == null)
                {
                    proveedorProducto = new ProveedorProducto();
                    proveedorProducto.Identifier = Guid.NewGuid();
                    proveedorProducto.ProductoId = compraProd.ProductoId;
                    proveedorProducto.ProveedorId = factura.ProveedorId;
                    proveedorProducto.CostoConIVA = compraProd.CostoActualizado.GetValueOrDefault();
                    proveedorProducto.CostoSinIVA = proveedorProducto.CostoConIVA / 1.21m;
                    proveedorProducto.FechaUltimoCambioCosto = DateTime.Now;
                    Uow.ProveedorProductos.Agregar(proveedorProducto);
                }
                else
                {
                    var nuevoCosto = compraProd.CostoActualizado ?? proveedorProducto.CostoConIVA;
                    if (nuevoCosto != proveedorProducto.CostoConIVA)
                        proveedorProducto.FechaUltimoCambioCosto = DateTime.Now;

                    proveedorProducto.CostoConIVA = nuevoCosto;
                    proveedorProducto.CostoSinIVA = proveedorProducto.CostoConIVA / 1.21m;
                    Uow.ProveedorProductos.Modificar(proveedorProducto);
                }

                ////Actualizar el precio y el costo del producto.
                var producto = Uow.Productos.Obtener(compraProd.ProductoId);
                producto.PrecioConIVA = compraProd.PrecioActualizado ?? producto.PrecioConIVA;
                producto.PrecioSinIVA = producto.PrecioConIVA / 1.21m;
                Uow.Productos.Modificar(producto);
            }

            Uow.Compras.Agregar(compra);
            Uow.Commit();
        }
        private void AgregarProductoAColeccion(ProductoCompleto producto)
        {
            var original = ProductosDatasource.FirstOrDefault(p => p.ProductoId == producto.ProductoId);
            if (original.CostoConIVA == null)
            {
                using (var frmCosto = new IngresarPrecioCosto(original.Descripcion, original.PrecioConIVA, 0, Factura.ProveedorNombre))
                {
                    if (frmCosto.ShowDialog() == DialogResult.OK)
                    {
                        //Modifico el costo de proveedor para ese producto
                        var proveedorProd = new ProveedorProducto()
                        {
                            CostoConIVA = frmCosto.Costo.GetValueOrDefault(),
                            ProductoId = original.ProductoId,
                            ProveedorId = ProveedorId,
                            Identifier = Guid.NewGuid(),
                            FechaUltimoCambioCosto = DateTime.Now
                        };
                        ProveedorProductoRepository.Agregar(proveedorProd);
                        ProveedorProductoRepository.Commit();
                        original.CostoConIVA = frmCosto.Costo;
                        original.PrecioConIVA = frmCosto.Precio;

                        AgregarProducto(original);
                    }
                }
            }
            else
            {
                AgregarProducto(original);
            }
        }
        private void ActualizarPropiedadesProducto(decimal precio, decimal? costo, decimal? costoAnterior)
        {
            DataGridViewRow row = dvgCompraProducto.SelectedRows[0];
            var item = dvgCompraProducto.SelectedRows[0].DataBoundItem as CompraProducto;
            var selectedIndex = row.Index;

            var cambio = false;
            //Modifico el precio
            var prod = ProductoRepository.Obtener(p => p.ProductoId == item.ProductoId);
            var compra = ComprasProducto.FirstOrDefault(c => c.ProductoId == item.ProductoId);

            if (prod.PrecioConIVA != precio)
            {

                prod.PrecioConIVA = precio;
                prod.PrecioSinIVA = precio / 1.21m;
                compra.PrecioActualizado = precio;

                ProductoRepository.Modificar(prod);
                ProductoRepository.Commit();
                cambio = true;
            }

            if (costo != costoAnterior && costo != null)
            {
                compra.CostoActualizado = costo;
                var factura = FacturaRepository.Obtener(f => f.FacturaId == ddlFacturas.Valor);
                if (costoAnterior != null)
                {
                    var proveedorProducto = ProveedorProductoRepository.Obtener(p => p.ProductoId == item.ProductoId
                                                                                     && p.ProveedorId == factura.ProveedorId);
                    if (proveedorProducto.CostoConIVA != costo.GetValueOrDefault())
                        proveedorProducto.FechaUltimoCambioCosto = DateTime.Now;
                    proveedorProducto.CostoConIVA = costo.GetValueOrDefault();
                    proveedorProducto.CostoSinIVA = proveedorProducto.CostoConIVA / 1.21m;

                    ProveedorProductoRepository.Modificar(proveedorProducto);
                }
                else
                {
                    var proveedorProducto = new ProveedorProducto
                                                {
                                                    CostoConIVA = costo.GetValueOrDefault(),
                                                    CostoSinIVA = costo.GetValueOrDefault() / 1.21m,
                                                    ProductoId = item.ProductoId,
                                                    ProveedorId = factura.ProveedorId,
                                                    FechaUltimoCambioCosto = DateTime.Now
                                                };
                    ProveedorProductoRepository.Agregar(proveedorProducto);
                }
                ProveedorProductoRepository.Commit();
                ActualizacionPantallasHelper.ActualizarPantallaVentas();

                cambio = true;
            }

            if (cambio)
            {
                RefrescarGrilla();
            }

            //Por alguna razon se pierde la seleccion, asi que selecciono la misma fila otra vez
            dvgCompraProducto.ClearSelection();
            dvgCompraProducto.Rows[selectedIndex].Selected = true;
            dvgCompraProducto.FirstDisplayedScrollingRowIndex = selectedIndex;
        }
        private void NuevoProducto()
        {
            var user = SeguridadHelper.SolicitarPermisosUsuario(new List<string>() { "SuperAdministrador", "Administrador", "Encargado" });
            if (user != 0)
            {
                using (var frm = new frmCrearProducto())
                {
                    if (frm.ShowDialog() == DialogResult.OK)
                    {
                        var prod = ProductoRepository.MaxiKioscosEntities
                                .ProductoListadoCompleto(AppSettings.MaxiKioscoId, null, frm.ProductoId).
                                FirstOrDefault();
                        using (var frmCosto = new IngresarCosto(prod.Descripcion))
                        {
                            if (frmCosto.ShowDialog() == DialogResult.OK)
                            {
                                //Modifico el costo de proveedor para ese producto
                                var proveedorProd = new ProveedorProducto()
                                {
                                    CostoConIVA = frmCosto.Costo.GetValueOrDefault(),
                                    ProductoId = prod.ProductoId,
                                    ProveedorId = ProveedorId,
                                    Identifier = Guid.NewGuid(),
                                    FechaUltimoCambioCosto = DateTime.Now
                                };
                                ProveedorProductoRepository.Agregar(proveedorProd);
                                ProveedorProductoRepository.Commit();
                                prod.CostoConIVA = frmCosto.Costo;

                                AgregarProducto(prod);
                            }
                            ProductosDatasource.Add(prod);
                        }

                    }
                }
            }
            txtCodigo.Text = string.Empty;
            txtCodigo.Focus();
        }