public frmEditarCorreccionStock(int correccionId)
        {
            using (var frm = new ConfirmationForm("Desea eliminar la corrección?","Aceptar","Cancelar"))
            {
                var result = frm.ShowDialog();
                if (result == DialogResult.OK)
                {
                    //Eliminar
                    var correcion = CorreccionStockRepository.Obtener(correccionId);
                    var tipocorreccion = MotivoRepository.Obtener(t => t.MotivoCorreccionId == correcion.MotivoCorreccionId);
                    EliminarCorreccion(correccionId);

                    Stock = StockRepository.Obtener(s => s.ProductoId == correcion.ProductoId
                                             && s.MaxiKioscoId == AppSettings.MaxiKioscoId);

                    ModificarStock((correcion.Cantidad * -1),tipocorreccion.SumarAStock);

                    AgregarStockTransaccion(Stock, correcion.Cantidad * -1);

                    MessageBox.Show("La corrección ha sido eliminada");

                    this.Close();

                }
            }
        }
        public ActionResult Editar(int productoId, int maxiKioscoId)
        {
            var repo = new EFRepository<Entidades.MaxiKiosco>();
            var maxi = repo.Obtener(maxiKioscoId);
            repo.MaxiKioscosEntities.StockActualizar(maxi.Identifier, productoId);
            Stock stock = Uow.Stocks.Obtener(s => s.ProductoId == productoId
                && s.MaxiKioscoId == maxiKioscoId,
                s => s.MaxiKiosco, s => s.Producto,
                s => s.StockTransacciones);

            if (stock == null)
            {
                stock = new Stock();

                var maxiKiosco = Uow.MaxiKioscos.Obtener(maxiKioscoId);
                var producto = Uow.Productos.Obtener(productoId);

                stock.MaxiKioscoId = maxiKioscoId;
                stock.ProductoId = productoId;
                stock.MaxiKiosco = maxiKiosco;
                stock.Producto = producto;
                stock.FechaCreacion = DateTime.Now;
                stock.OperacionCreacion = "Edición en web";
            }

            var model = new StockModel()
            {
                MaxiKiosco = stock.MaxiKiosco.Nombre,
                MotivoCorreccionId = UsuarioActual.Cuenta.MotivoCorreccionPorDefecto,
                Producto = stock.Producto.Descripcion,
                StockActual = stock.StockActual,
                PrecioConIVA = stock.Producto.PrecioConIVA,
                Stock = stock
            };

            return PartialView(model);
        }
        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 ProcesarStock(TransferenciaProducto transferenciaProd, bool sumar, int maxikioscoId)
        {
            var stockTransaccion = new StockTransaccion
            {
                Identifier = Guid.NewGuid(),
                Cantidad = sumar ? transferenciaProd.Cantidad : -transferenciaProd.Cantidad,
                StockTransaccionTipoId = 4, //Transferencia
                FechaUltimaModificacion = DateTime.Now
            };

            //Obtengo la instancia de stock para la transferencia del producto
            Stock stock = Uow.Stocks.Obtener(s => s.MaxiKioscoId == maxikioscoId && s.ProductoId == transferenciaProd.ProductoId);
            if (stock == null)
            {
                stock = new Stock
                {
                    Identifier = Guid.NewGuid(),
                    MaxiKioscoId = maxikioscoId,
                    ProductoId = transferenciaProd.ProductoId,
                    OperacionCreacion = "Aprobar transferencia desde web",
                    FechaCreacion = DateTime.Now
                };
                Uow.Stocks.Agregar(stock);
            }

            stockTransaccion.Stock = stock;
            Uow.StockTransacciones.Agregar(stockTransaccion);
        }
        private void CargarProducto(ProductoCompleto original)
        {
            //Busco el stock para traer la cantidad
            Stock = StockRepository.Obtener(s => s.ProductoId == original.ProductoId
                                              && s.MaxiKioscoId == AppSettings.MaxiKioscoId);

            Descripcion = original.Descripcion;
            Precio = original.PrecioConIVA;
            // controlo que haya stock de este producto
            if (Stock == null )
            {
                MessageBox.Show("No existe stock de este producto");
                DeshabilitarEdicion();

            }
            else if (Stock.StockActual == 0)
            {
                MessageBox.Show("No hay stock del producto");
                DeshabilitarEdicion();
            }
            else
            {
                HabilitarEdicion();
            }
            CargarMotivo();
        }
 private void AgregarStockTransaccion(Stock stock)
 {
     var StockTransaccion = new StockTransaccion();
     StockTransaccion.StockId = stock.StockId;
     StockTransaccion.Identifier = Guid.NewGuid();
     StockTransaccion.Desincronizado = true;
     StockTransaccion.FechaUltimaModificacion = DateTime.Now;
     StockTransaccion.Eliminado = false;
     StockTransaccion.Cantidad = Convert.ToDecimal(CantidadActual);
     StockTransaccion.StockTransaccionTipoId = 3;
     StockTransaccionRepository.Agregar(StockTransaccion);
     StockTransaccionRepository.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();
                }
            }
        }
        private void CargarProducto(ProductoCompleto original)
        {
            txtCodigo.Text = original.Descripcion;
            //Busco el stock para traer la cantidad
            Stock = StockRepository.Obtener(s => s.ProductoId == original.ProductoId
                                              && s.MaxiKioscoId == AppSettings.MaxiKioscoId);

            Producto = original;
            Descripcion = original.Descripcion;
            Precio = original.PrecioConIVA;
            // controlo que haya stock de este producto

            CantidadOriginal = Stock == null ? "0" : Stock.StockActual.ToString();
            HabilitarEdicion();
        }
        private void btnAceptar_Click(object sender, EventArgs e)
        {
            errorProvider1.Dispose();

            var valido = Validacion.Validar(errorProvider1, new List<object>
                                                  {
                                                      txtCantidadActual
                                                  });

            if (valido)
            {
                if (Stock == null)
                {
                    Stock = AgregarStock(Producto.ProductoId, Convert.ToDecimal(txtCantidadActual.Valor));
                    Stock = StockRepository.Obtener(s => s.ProductoId == Producto.ProductoId);
                    this.DialogResult = DialogResult.OK;
                }
                else
                    ModificarStock(Convert.ToDecimal(CantidadActual), false);

                AgregarCorreccion(Producto);

                var incremento = Convert.ToDecimal(CantidadActual)*-1;
                AgregarStockTransaccion(Stock, incremento);

                this.DialogResult = DialogResult.OK;
            }

            else
                this.DialogResult = DialogResult.None;
        }
 private void AgregarStockTransaccion(Stock stock,decimal cantidad)
 {
     var stockTransaccion = new StockTransaccion
                                {
                                    StockId = stock.StockId,
                                    Identifier = Guid.NewGuid(),
                                    Desincronizado = true,
                                    FechaUltimaModificacion = DateTime.Now,
                                    Eliminado = false,
                                    Cantidad = cantidad,
                                    StockTransaccionTipoId = 3
                                };
     StockTransaccionRepository.Agregar(stockTransaccion);
     StockTransaccionRepository.Commit();
 }
 private Stock AgregarStock(int productoid, decimal stockactual)
 {
     var stock = new Stock
                     {
                         ProductoId = productoid,
                         MaxiKioscoId = AppSettings.MaxiKioscoId,
                         Identifier = Guid.NewGuid(),
                         StockActual = stockactual,
                         Desincronizado = true,
                         FechaUltimaModificacion = DateTime.Now,
                         Eliminado = false,
                         OperacionCreacion = "Correccion de stock DESKTOP",
                         FechaCreacion = DateTime.Now
                     };
     StockRepository.Agregar(stock);
     StockRepository.Commit();
     return stock;
 }
Beispiel #12
0
        private void Aceptar()
        {
            if (PopupAbierto)
                PopupAbierto = false;
            else if (MensajeErrorAbierto)
                MensajeErrorAbierto = false;
            else if (ConfirmacionAbierta)
            {
                ConfirmacionAbierta = false;
            }
            else
            {
                if (dgvListado.Rows.Count > 0)
                {
                    var lineas = new List<VentaProducto>();
                    decimal total = 0;
                    decimal costoTotal = 0;
                    for (int i = 0; i <= dgvListado.Rows.Count - 1; i++)
                    {
                        var linea = new VentaProducto();

                        linea.Cantidad = decimal.Parse(dgvListado.Rows[i].Cells["Cantidad"].Value.ToString());
                        linea.Eliminado = false;
                        linea.Identifier = Guid.NewGuid();
                        linea.Precio = Convert.ToDecimal(dgvListado.Rows[i].Cells["Unitario"].Value.ToString().Replace("$", ""));
                        linea.ProductoId = (int)dgvListado.Rows[i].Cells["productoId"].Value;
                        linea.Costo = dgvListado.Rows[i].Cells["Costo"].Value == null
                                                ? 0
                                                : Convert.ToDecimal(dgvListado.Rows[i].Cells["Costo"].Value.ToString().Replace("$", ""));

                        var recargo = dgvListado.Rows[i].Cells["Recargo"].Value;
                        linea.EsPromocion = bool.Parse(dgvListado.Rows[i].Cells["EsPromocion"].Value.ToString());
                        linea.AdicionalPorExcepcion = recargo == null
                                                                ? (decimal?)null :
                                                                Convert.ToDecimal(recargo.ToString().Replace("$", "")) * linea.Cantidad;
                        linea.Desincronizado = true;

                        total += Convert.ToDecimal(linea.Cantidad) * linea.Precio.GetValueOrDefault();
                        costoTotal += Convert.ToDecimal(linea.Cantidad) * linea.Costo;
                        lineas.Add(linea);
                    }

                    ConfirmacionAbierta = true;
                    var frmConfirmar = new frmConfirmarVenta(total);
                    if (frmConfirmar.ShowDialog() == DialogResult.OK)
                    {
                        ConfirmacionAbierta = false;
                        var venta = new Venta
                        {
                            ImporteTotal = total,
                            CostoTotal = costoTotal,
                            Identifier = Guid.NewGuid(),
                            Eliminado = false,
                            CierreCajaId = UsuarioActual.CierreCajaIdActual,
                            FechaVenta = DateTime.Now,
                            VentaProductos = lineas
                        };
                        venta.CierreCajaId = UsuarioActual.CierreCajaIdActual;
                        var stockRepository = new StockRepository();
                        var stockTransaccionRepository = new EFRepository<StockTransaccion>();

                        var seAgregoStock = false;
                        var seAgregoTransaccion = false;

                        //Agrego primero a la coleccion las lineas secundarias correspondientes a promociones
                        var secundarias = new List<VentaProducto>();
                        foreach (var linea in lineas.Where(l => l.EsPromocion))
                        {
                            var productos = ProductoPromocionRepository.Listado().Where(p => p.PadreId == linea.ProductoId && !p.Eliminado).ToList();
                            secundarias.AddRange(productos.Select(p => new VentaProducto()
                                                                       {
                                                                           Cantidad = p.Unidades * linea.Cantidad,
                                                                           ProductoId = p.HijoId
                                                                       }));
                        }

                        lineas.AddRange(secundarias);

                        foreach (var line in lineas)
                        {
                            var stockSt = new StockTransaccion
                            {
                                Cantidad = line.Cantidad * (-1),
                                StockTransaccionTipoId = 1,
                                Identifier = Guid.NewGuid(),
                                Desincronizado = true
                            };

                            var stock = stockRepository.ObtenerByProducto(line.ProductoId, AppSettings.MaxiKioscoId);
                            if (stock != null)
                            {
                                stockSt.StockId = stock.StockId;
                                stock.StockActual = stock.StockActual - Convert.ToDecimal(line.Cantidad);
                                stockTransaccionRepository.Agregar(stockSt);
                                stockRepository.Modificar(stock);
                                seAgregoTransaccion = true;
                                seAgregoStock = true;
                            }
                            else
                            {
                                stock = new Stock()
                                {
                                    Identifier = Guid.NewGuid(),
                                    MaxiKioscoId = AppSettings.MaxiKioscoId,
                                    ProductoId = line.ProductoId,
                                    StockActual = -line.Cantidad,
                                    OperacionCreacion = "Venta en DESKTOP",
                                    FechaCreacion = DateTime.Now,
                                    StockTransacciones = new List<StockTransaccion> { stockSt }
                                };
                                stockRepository.Agregar(stock);
                                seAgregoStock = true;
                            }
                        }

                        if (seAgregoStock)
                            stockRepository.Commit();
                        if (seAgregoTransaccion)
                            stockTransaccionRepository.Commit();

                        Repository.Agregar(venta);
                        if (Repository.Commit())
                        {
                            Limpiar();
                        }
                        else
                        {
                            Mensajes.Guardar(false, "Ha ocurrido un error al registrar la venta. Por favor intente nuevamente");
                        }
                        ReiniciarVenta();
                    }
                }
            }
        }
        private void ActualizarStock(Producto producto, string operacion)
        {
            var seActualizo = false;
            foreach (var promo in producto.PromocionMaxikioscos)
            {
                seActualizo = true;
                var diferencia = promo.StockActual - promo.StockAnterior;
                if (diferencia != 0)
                {
                    var stock = Uow.Stocks.Obtener(s => s.ProductoId == producto.ProductoId && s.MaxiKioscoId == promo.MaxiKioscoId);
                    if (stock == null)
                    {
                        stock = new Stock
                        {
                            ProductoId = producto.ProductoId,
                            MaxiKioscoId = promo.MaxiKioscoId,
                            StockActual = promo.StockActual,
                            Identifier = Guid.NewGuid(),
                            Desincronizado = true,
                            OperacionCreacion = operacion + " desde promociones web",
                            FechaCreacion = DateTime.Now,
                            StockTransacciones = new List<StockTransaccion>()
                            {
                                new StockTransaccion()
                                {
                                    Cantidad = diferencia,
                                    Desincronizado = true,
                                    Eliminado = false,
                                    Identifier = Guid.NewGuid(),
                                    StockTransaccionTipoId = 3
                                }
                            }
                        };
                        Uow.Stocks.Agregar(stock);
                    }
                    else
                    {
                        stock.StockActual += diferencia;
                        Uow.Stocks.Modificar(stock);

                        var trans = new StockTransaccion()
                        {
                            Desincronizado = true,
                            Identifier = Guid.NewGuid(),
                            Cantidad = diferencia,
                            StockId = stock.StockId,
                            StockTransaccionTipoId = 3
                        };
                        Uow.StockTransacciones.Agregar(trans);
                    }
                }

            }

            if (seActualizo)
            {
                Uow.Commit();;
            }
        }
        public ActionResult Transferir(int productoId, int maxiKioscoId)
        {
            Stock stock = Uow.Stocks.Obtener(s => s.ProductoId == productoId
                && s.MaxiKioscoId == maxiKioscoId,
                s => s.MaxiKiosco, s => s.Producto,
                s => s.StockTransacciones);

            if (stock == null)
            {
                stock = new Stock();

                var maxiKiosco = Uow.MaxiKioscos.Obtener(maxiKioscoId);
                var producto = Uow.Productos.Obtener(productoId);

                stock.MaxiKioscoId = maxiKioscoId;
                stock.ProductoId = productoId;
                stock.MaxiKiosco = maxiKiosco;
                stock.Producto = producto;
                stock.FechaCreacion = DateTime.Now;
                stock.OperacionCreacion = "Transferencia manual en web";
                stock.Identifier = Guid.NewGuid();
            }

            stock.StockActual = stock.StockTransacciones
                .Select(st => st.Cantidad)
                .DefaultIfEmpty(0).Sum();

            var model = new TransferirStockModel
                            {
                                Stock = stock,
                                Unidades = 1
                            };

            return PartialView(model);
        }
        public void ActualizarStock(Stock stock, decimal diferencia, int motivoCorreccionId, decimal precioConIVA)
        {
            ////Obtenemos el producto a actualizar
            var producto = Uow.Productos.Obtener(stock.ProductoId);

            if (producto == null)
                throw new ApplicationException("No se ha encontrado el producto");

            if (!producto.AceptaCantidadesDecimales && (stock.StockActual % 1 != 0))
                throw new ApplicationException("El producto no acepta cantidades decimales");

            var stockTransaccion = new StockTransaccion();
            var now = DateTime.Now;

            producto.PrecioConIVA = precioConIVA;
            producto.PrecioSinIVA = precioConIVA / 1.21m;

            //3 = Corrección
            stockTransaccion.StockTransaccionTipoId = 3;
            stockTransaccion.Identifier = Guid.NewGuid();

            var motivo = Uow.MotivosCorreccion.Obtener(motivoCorreccionId);
            if (!motivo.SumarAStock)
            {
                diferencia = -diferencia;
            }

            var stockTransacciones = Uow.StockTransacciones.Listado().Where(st => st.StockId == stock.StockId);

            //Creamos una nueva transaccion con la diferencia entre el stock actual y el ingresado por el usuario.
            var stockActual = stockTransacciones.Select(st => st.Cantidad)
                .DefaultIfEmpty(0)
                .Sum();

            stock.StockActual = stockActual + diferencia;

            if (stock.StockId == 0)
            {
                stock.Identifier = Guid.NewGuid();
                Uow.Stocks.Agregar(stock);

                stockTransaccion.Stock = stock;
                stockTransaccion.Cantidad = diferencia;
            }
            else
            {
                stockTransaccion.Cantidad = diferencia;
                stockTransaccion.StockId = stock.StockId;
                Uow.Stocks.Modificar(stock);
            }

            Uow.StockTransacciones.Agregar(stockTransaccion);

            ////Agregamos la correccion de stock.
            var correccionStock = new CorreccionStock();

            correccionStock.Cantidad = stockTransaccion.Cantidad;
            correccionStock.MotivoCorreccionId = motivoCorreccionId;
            correccionStock.ProductoId = stock.ProductoId;
            correccionStock.Precio = producto.PrecioConIVA;
            correccionStock.Fecha = now;
            correccionStock.Identifier = Guid.NewGuid();
            correccionStock.MaxiKioscoId = stock.MaxiKioscoId;

            ////Set sincronization properties.
            correccionStock.FechaUltimaModificacion = now;
            correccionStock.Desincronizado = true;

            Uow.Productos.Modificar(producto);
            Uow.CorreccionesDeStock.Agregar(correccionStock);

            Uow.Commit();
        }
        public void TransferirStock(Stock stockOrigen, int unidades, int destinoId)
        {
            ////Obtenemos el producto a actualizar
            var producto = Uow.Productos.Obtener(stockOrigen.ProductoId);

            if (producto == null)
                throw new ApplicationException("No se ha encontrado el producto");

            var now = DateTime.Now;

            //Actualizo el origen
            var transOrigen = new StockTransaccion
                                  {
                                      Cantidad = -unidades,
                                      Identifier = Guid.NewGuid(),
                                      FechaUltimaModificacion = now,
                                      StockTransaccionTipoId = 3
                                  };
            if (stockOrigen.StockId == 0)
            {
                stockOrigen.StockActual = -unidades;
                stockOrigen.StockTransacciones = new Collection<StockTransaccion> { transOrigen };
                Uow.Stocks.Agregar(stockOrigen);
            }
            else
            {
                stockOrigen.StockActual -= unidades;
                stockOrigen.FechaUltimaModificacion = now;
                Uow.Stocks.Modificar(stockOrigen);

                transOrigen.StockId = stockOrigen.StockId;
                Uow.StockTransacciones.Agregar(transOrigen);
            }

            var correccionOrigen = new CorreccionStock
                                       {
                                           Cantidad = transOrigen.Cantidad,
                                           MotivoCorreccionId = 5, //Transferencia
                                           ProductoId = stockOrigen.ProductoId,
                                           Precio = producto.PrecioConIVA,
                                           Fecha = now,
                                           Identifier = Guid.NewGuid(),
                                           MaxiKioscoId = stockOrigen.MaxiKioscoId,
                                           FechaUltimaModificacion = now,
                                           Desincronizado = true
                                       };
            Uow.CorreccionesDeStock.Agregar(correccionOrigen);

            //Ahora actualizo el destino
            var transDestino = new StockTransaccion
                                  {
                                      Cantidad = unidades,
                                      Identifier = Guid.NewGuid(),
                                      FechaUltimaModificacion = now,
                                      StockTransaccionTipoId = 3
                                  };

            var stockDestino = Uow.Stocks.Obtener(s => s.MaxiKioscoId == destinoId && s.ProductoId == stockOrigen.ProductoId);
            if (stockDestino == null)
            {
                stockDestino = new Stock()
                                   {
                                       Desincronizado = true,
                                       Identifier = Guid.NewGuid(),
                                       MaxiKioscoId = destinoId,
                                       ProductoId = stockOrigen.ProductoId,
                                       StockActual = unidades,
                                       OperacionCreacion = "Recibido desde transferencia",
                                       FechaCreacion = DateTime.Now,
                                       StockTransacciones = new Collection<StockTransaccion> { transDestino }
                                   };
                Uow.Stocks.Agregar(stockDestino);
            }
            else
            {
                stockDestino.FechaUltimaModificacion = now;
                stockDestino.StockActual += unidades;
                Uow.Stocks.Modificar(stockDestino);

                transDestino.StockId = stockDestino.StockId;
                Uow.StockTransacciones.Agregar(transDestino);
            }

            var correccionDestino = new CorreccionStock
            {
                Cantidad = transDestino.Cantidad,
                MotivoCorreccionId = 5, //Transferencia
                ProductoId = stockOrigen.ProductoId,
                Precio = producto.PrecioConIVA,
                Fecha = now,
                Identifier = Guid.NewGuid(),
                MaxiKioscoId = stockDestino.MaxiKioscoId,
                FechaUltimaModificacion = now,
                Desincronizado = true
            };
            Uow.CorreccionesDeStock.Agregar(correccionDestino);

            Uow.Commit();
        }