public ActionResult Crear()
        {
            var compra = new Compra() { Fecha = DateTime.Now };
            ViewBag.CantidadIngresada = null;

            return PartialView(compra);
        }
        public ActionResult Crear(Compra compra)
        {
            if (!ModelState.IsValid)
            {
                return new HttpStatusCodeResult(HttpStatusCode.InternalServerError);
            }

            compra.CuentaId = UsuarioActual.CuentaId;
            ComprasNegocio.Crear(compra);

            return Json(new { exito = true });
        }
Ejemplo n.º 3
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 btnAceptar_Click(object sender, EventArgs e)
        {
            if (ComprasProducto.Count == 0)
            {
                MessageBox.Show("Debe ingresar al menos un producto");
            }
            else
            {
                //Comparo el total con el maximo margen configurado
                var margenImporte = Cuenta.MargenImporteFactura;
                if (Math.Abs(ImporteFinal - Factura.ImporteTotal) > (margenImporte ?? 10))
                {
                    MessageBox.Show(String.Format(
                            "No se puede cargar la factura. El importe total (${0}) difiere del importe de la factura (${1}) en un valor mayor al máximo margen de factura establecido (${2})",
                            ImporteFinal.ToString("N2"),
                            Factura.ImporteTotal.ToString("N2"),
                            (margenImporte ?? 10).ToString("N2")));
                }
                else
                {
                    //Inserto la Compra
                    var comprasProducto = ComprasProducto.Select(c => new CompraProducto()
                                                    {
                                                        Cantidad = c.Cantidad,
                                                        CostoActual = c.CostoActual,
                                                        CostoActualizado = c.CostoActualizado,
                                                        PrecioActual = c.PrecioActual,
                                                        PrecioActualizado = c.PrecioActualizado,
                                                        ProductoId = c.ProductoId,
                                                        Eliminado = false,
                                                        Desincronizado = true,
                                                        Identifier = Guid.NewGuid(),
                                                        FechaUltimaModificacion = DateTime.Now
                                                    }).ToList();
                    var compra = new Compra()
                                     {
                                         CuentaId = Usuario.CuentaId,
                                         FacturaId = Factura.FacturaId,
                                         Fecha = DateTime.Now,
                                         MaxiKioscoId = AppSettings.MaxiKioscoId,
                                         Numero = Factura.AutoNumero,
                                         ComprasProductos = comprasProducto,
                                         Eliminado = false,
                                         Desincronizado = true,
                                         Identifier = Guid.NewGuid(),
                                         FechaUltimaModificacion = DateTime.Now,
                                         ImporteFactura = txtImporteTotal.Valor.GetValueOrDefault(),
                                         Descuento = txtDescuento.Valor.GetValueOrDefault(),
                                         ImporteFinal = ImporteFinal,
                                         PercepcionDGR = txtDGR.Valor.GetValueOrDefault(),
                                         PercepcionIVA = txtIVA.Valor.GetValueOrDefault(),
                                         TotalCompra = txtTotalCompra.Valor.GetValueOrDefault(),
                                         TipoComprobante = ddlTipoComprobante.Texto
                                     };

                    foreach (var prod in comprasProducto)
                    {
                        //Actualizo el stock
                        var stock = StockRepository.Obtener(s => s.ProductoId == prod.ProductoId
                                                                 && s.MaxiKioscoId == AppSettings.MaxiKioscoId);

                        var transaccion = new StockTransaccion
                                              {
                                                  Cantidad = prod.Cantidad,
                                                  StockTransaccionTipoId = 2,
                                                  Identifier = Guid.NewGuid(),
                                                  FechaUltimaModificacion = DateTime.Now,
                                                  Desincronizado = true
                                              };
                        if (stock == null)
                        {
                            stock = new Stock()
                                                    {
                                                        MaxiKioscoId = AppSettings.MaxiKioscoId,
                                                        ProductoId = prod.ProductoId,
                                                        StockActual = transaccion.Cantidad,
                                                        Eliminado = false,
                                                        Desincronizado = true,
                                                        Identifier = Guid.NewGuid(),
                                                        FechaUltimaModificacion = DateTime.Now,
                                                        FechaCreacion = DateTime.Now,
                                                        OperacionCreacion = "Compra desde desktop"
                                                    };
                            StockRepository.Agregar(stock);
                            StockRepository.Commit();
                        }
                        transaccion.StockId = stock.StockId;
                        StockTransaccionRepository.Agregar(transaccion);

                        //Modifico el precio
                        var producto = ProductoRepository.Obtener(prod.ProductoId);
                        producto.PrecioConIVA = prod.PrecioActualizado.GetValueOrDefault();
                        producto.PrecioSinIVA = prod.PrecioActualizado.GetValueOrDefault() == 0 ? 0 : prod.PrecioActual / 1.21m;

                        ProductoRepository.Modificar(producto);
                    }
                    StockTransaccionRepository.Commit();

                    FacturaRepository.Modificar(Factura);
                    FacturaRepository.Commit();

                    CompraRepository.Agregar(compra);
                    CompraRepository.Commit();

                    StockRepository.Actualizar(AppSettings.MaxiKioscoIdentifier);

                    MessageBox.Show(Resources.CompraExitosa);
                    this.Close();
                }
            }
        }