public bool Cerrar(int controlStockId, List<ControlStockDetalle> listado)
{
var motivos = Uow.MotivosCorreccion.Listado();
var detalles = listado.Where(d => d.MotivoCorreccionId != null).ToList();
if (detalles.Any())
{
foreach (var controlStockDetalle in detalles)
{
var stock = Uow.Stocks.Obtener(controlStockDetalle.StockId);
var transaccion = new StockTransaccion()
{
Desincronizado = true,
Eliminado = false,
FechaUltimaModificacion = DateTime.Now,
Identifier = Guid.NewGuid(),
StockId = controlStockDetalle.StockId,
StockTransaccionTipoId = 3 //Correccion
};
var motivo = motivos.FirstOrDefault(m => m.MotivoCorreccionId == controlStockDetalle.MotivoCorreccionId);
transaccion.Cantidad = motivo.SumarAStock
? controlStockDetalle.Correccion.GetValueOrDefault()
: -controlStockDetalle.Correccion.GetValueOrDefault();
Uow.StockTransacciones.Agregar(transaccion);
stock.StockActual += transaccion.Cantidad;
Uow.Stocks.Modificar(stock);
controlStockDetalle.Desincronizado = true;
Uow.ControlStockDetalles.Modificar(controlStockDetalle);
}
}
var control = Uow.ControlesStock.Obtener(controlStockId);
control.FechaCorreccion = DateTime.Now;
control.Cerrado = true;
control.Desincronizado = true;
Uow.ControlesStock.Modificar(control);
Uow.Commit();
//Deshabilito todos los ControlStockDetalle con controlStock abierto para el mismo stock
if (detalles.Any())
Uow.ControlesStock.DeshabilitarAbiertos(controlStockId, detalles.Select(d => d.StockId).ToArray());
return true;
}
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 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 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 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 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();
}
