public IActionResult EgresoMateriaPrima(MovimientoInventario movimientoInventario)
{
ViewData["ProveedorFk"] = new SelectList(_context.Proveedor, "NumeroProveedor", "NombreProveedor");
ViewData["InventarioFk"] = new SelectList(_context.Agregado, "CodMateriaPrima", "NombreMateriaPrima");
var listInventario = _context.Inventario.Where(i => i.AgregadoFk == movimientoInventario.InventarioFk).FirstOrDefault();
Random ran = new Random();
if (movimientoInventario.Cantidad < listInventario.Total)
{
if (ModelState.IsValid)
{
listInventario.Total = listInventario.Total - movimientoInventario.Cantidad;
movimientoInventario.InventarioFk = listInventario.CodInventario;
if (User.Identity.IsAuthenticated)
{
movimientoInventario.Digitador = User.FindFirst(ClaimTypes.NameIdentifier).Value;
movimientoInventario.FechaDigitador = DateTime.Now;
movimientoInventario.FechaMovimiento = DateTime.Now;
movimientoInventario.TipoMovimiento = "E";
}
// movimientoInventario.Factura = ran.Next(20, 100).ToString();
// movimientoInventario.PrecioUnitario = ran.Next(20, 100);
_context.Add(movimientoInventario);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
}
// var listInventarios = _context.Inventario;
return(View());
}
public async Task <IActionResult> PutMovimientoInventario(int id, MovimientoInventario movimientoInventario)
{
if (id != movimientoInventario.Id)
{
return(BadRequest());
}
_context.Entry(movimientoInventario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovimientoInventarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id, [Bind("CodMovimientoInventario,TipoMovimiento,FechaMovimiento,Factura,PrecioUnitario,Cantidad,Observacion,InventarioFk,ProveedorFk,OrdenAprovisionamientoFk,Digitador,FechaDigitador")] MovimientoInventario movimientoInventario)
{
if (id != movimientoInventario.CodMovimientoInventario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movimientoInventario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovimientoInventarioExists(movimientoInventario.CodMovimientoInventario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["InventarioFk"] = new SelectList(_context.Inventario, "CodInventario", "CodInventario", movimientoInventario.InventarioFk);
ViewData["OrdenAprovisionamientoFk"] = new SelectList(_context.OrdenAprovisionamiento, "NumeroOrdenAprovisionamiento", "NumeroOrdenAprovisionamiento", movimientoInventario.OrdenAprovisionamientoFk);
ViewData["ProveedorFk"] = new SelectList(_context.Proveedor, "NumeroProveedor", "NumeroProveedor", movimientoInventario.ProveedorFk);
return(View(movimientoInventario));
}
public async Task BuscarInventario(int productoId, int depositoId)
{
if (productoId != 0 && depositoId != 0)
{
inventario = await http.GetJsonAsync <Inventario>($"api/inventario/DetalleInventario?productoId={productoId}&depositoId={depositoId}");
paginaActual = 1;
if (inventario.Id != 0)
{
await ListarMovimientosInventario(paginaActual);
}
movimientoInventario = new MovimientoInventario
{
Inventario = new Inventario
{
ProductoPresentacion = productoPresentacion,
Deposito = deposito,
ProductoPresentacionId = productoPresentacion.Id,
DepositoId = deposito.Id,
Id = inventario.Id
}
,
InventarioId = inventario.Id
};
}
}
public async Task <ActionResult <OrdenProduccion> > PostOrdenProduccion(OrdenProduccion ordenProduccion)
{
try
{
ordenProduccion.Deposito = null;
ordenProduccion.detallesOrdenProduccion.ForEach(x => x.ProductoPresentacion = null);
_context.ordenProduccion.Add(ordenProduccion);
ordenProduccion.EstadoOrdenProduccionId = 1;
await _context.SaveChangesAsync();
ordenProduccion = await _context.ordenProduccion
.Include(x => x.detallesOrdenProduccion)
.FirstOrDefaultAsync(x => x.Id == ordenProduccion.Id);
foreach (DetalleOrdenProduccion detalle in ordenProduccion.detallesOrdenProduccion)
{
Inventario inventarioDb = _context.inventario.FirstOrDefault(x => x.DepositoId == ordenProduccion.DepositoId && x.ProductoPresentacionId == detalle.ProductoPresentacionId);
if (inventarioDb == null)
{
inventarioDb = new Inventario {
DepositoId = ordenProduccion.DepositoId, ProductoPresentacionId = detalle.ProductoPresentacionId
};
_context.inventario.Add(inventarioDb);
await _context.SaveChangesAsync();
}
//
inventarioDb.cantidadUnidadesEnExistencia += detalle.cantidad;
_context.Entry(inventarioDb).State = EntityState.Modified;
MovimientoInventario movimiento = new MovimientoInventario
{
cantidadUnidadesMovida = detalle.cantidad,
entra = true,
sale = false,
InventarioId = inventarioDb.Id,
OrdenProduccionId = ordenProduccion.Id
};
_context.Entry(movimiento).State = EntityState.Added;
}
_context.Entry(ordenProduccion).State = EntityState.Unchanged;
await _context.SaveChangesAsync();
return(CreatedAtAction("GetOrdenProduccion", new { id = ordenProduccion.Id }, ordenProduccion));
}
catch (Exception ex)
{
throw;
}
}
public async Task <IActionResult> Create(MovimientoInventario movimientoInventario)
{
if (ModelState.IsValid)
{
_context.Add(movimientoInventario);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["InventarioFk"] = new SelectList(_context.Inventario, "CodInventario", "CodInventario", movimientoInventario.InventarioFk);
ViewData["OrdenAprovisionamientoFk"] = new SelectList(_context.OrdenAprovisionamiento, "NumeroOrdenAprovisionamiento", "NumeroOrdenAprovisionamiento", movimientoInventario.OrdenAprovisionamientoFk);
ViewData["ProveedorFk"] = new SelectList(_context.Proveedor, "NumeroProveedor", "NumeroProveedor", movimientoInventario.ProveedorFk);
return(View(movimientoInventario));
}
public static MovimientoInventario CrearDevolucionProveedor(int iProveedorID, int iOrigenID, decimal mImporte, string sObservacion)
{
var oMov = new MovimientoInventario()
{
TipoOperacionID = Cat.TiposDeOperacionMovimientos.DevolucionAProveedor,
ProveedorID = iProveedorID,
// DevolucionOrigenID = iOrigenID,
ImporteTotal = mImporte,
Observacion = sObservacion
};
Datos.Guardar <MovimientoInventario>(oMov);
return(oMov);
}
public async Task BuscarInventario()
{
if (inventarioId != 0 && inventarioId != null)
{
inventario = await http.GetJsonAsync <Inventario>($"api/inventario/{inventarioId}");
paginaActual = 1;
await ListarMovimientosInventario(paginaActual);
deposito = inventario.Deposito;
productoPresentacion = inventario.ProductoPresentacion;
movimientoInventario = new MovimientoInventario {
Inventario = inventario, InventarioId = inventario.Id
};
}
}
// GET: /MovimientoInventarioResidente/Create
public ActionResult Create()
{
string usuario = System.Web.HttpContext.Current.Session["User"].ToString();
ViewBag.MovimientoInventarioId = new SelectList(db.MovimientoInventario, "MovimientoInventarioId", "Consecutivo");
// ViewBag.EstadoMovimientoId = new SelectList(db.EstadoMovimientoes, "EstadoMovimientoId", "Descripcion");
// ViewBag.TerceroId = new SelectList(db.Terceroes, "TerceroId", "RazonSocial");
var _tmusu = from c in db.TipoMovimiento join cm in db.UsuarioTipoMovimiento on c.TipoMovimientoId equals cm.TipoMovimientoId where cm.Usuario.Login == usuario select c;
//validar los movimientos de entrada y salida de medicamentos --> preconfigurarlos
ViewBag.TipoMovimientoId = new SelectList(_tmusu, "TipoMovimientoId", "Descripcion");
// ViewBag.UbicacionDestinoId = new SelectList(db.UbicacionDestino, "UbicacionDestinoId", "Descripcion");
MovimientoInventario movimiento = new MovimientoInventario();
movimiento.Fecha = DateTime.Now;
MovimientoInventarioResidente movimientoResidente = new MovimientoInventarioResidente();
movimientoResidente.MovimientoInventario = movimiento;
return(View());
}
private void btnFinish_Click(object sender, EventArgs e)
{
try
{
if (!this.ValidarFinal())
return;
int iAutorizoID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
if (ResU.Exito)
iAutorizoID = ResU.Respuesta.UsuarioID;
else
{
Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
return;
}
var res = Util.MensajePregunta("¿Está seguro de que la información es correcta?", GlobalClass.NombreApp);
if (res == DialogResult.No)
return;
SplashScreen.Show(new Splash());
this.btnFinish.Enabled = false;
var proveedorId = Util.Entero(this.cboProveedor.SelectedValue);
var sucursalId = Util.Entero(this.cboUbicacionDestino.SelectedValue);
var iva = 1 + (GlobalClass.ConfiguracionGlobal.IVA / 100);
switch (Util.Entero(cboTipoOperacion.SelectedValue))
{
case 1:
#region [ Entrada Compra ]
// Se valida que no se haya utilizado ese folio de factura
var folio = Datos.GetEntity<MovimientoInventario>(m => m.ProveedorID == proveedorId
&& m.FolioFactura == this.txtFolioFactura.Text && m.Estatus.Equals(true));
if (folio != null)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
var msj = string.Format("{0} {1} {2}", "El Folio Factura", this.txtFolioFactura.Text, "Ya fue utilizado con el proveedor seleccionado.");
Util.MensajeError(msj, GlobalClass.NombreApp);
return;
}
//Insertar Movimiento
var subtotal = Util.Decimal(this.txtSubtotal.Text);
var importeTotal = Util.Decimal(this.lblTotal.Text);
var movimientoEntrada = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
ProveedorID = proveedorId,
SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
FechaFactura = this.dtpFechaFacturacion.Value,
FechaRecepcion = this.dtpFechaRecepcion.Value,
FolioFactura = this.txtFolioFactura.Text,
Subtotal = subtotal,
IVA = importeTotal - subtotal,
ImporteTotal = importeTotal,
FueLiquidado = false,
TipoConceptoOperacionID = null,
Observacion = this.txtObservaciones.Text,
Articulos = Util.Decimal(this.txtArticulos.Text),
Unidades = Util.Decimal(this.txtUnidades.Text),
Seguro = Util.Decimal(this.txtSeguro.Text),
ImporteTotalSinDescuento = Util.Decimal(this.lblTotalSinDescuento.Text),
ImporteFactura = Util.Decimal(this.lblImporteFactura.Text)
};
Datos.Guardar<MovimientoInventario>(movimientoEntrada);
if (movimientoEntrada.MovimientoInventarioID < 1)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
foreach (DataGridViewRow row in this.dgvDetalleDescuentos.Rows)
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var cantidad = Util.Decimal(row.Cells["UNS"].Value);
var detalleMovimiento = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
ParteID = parteId,
Cantidad = cantidad,
PrecioUnitario = Util.Decimal(row.Cells["Unitario"].Value),
Importe = Util.Decimal(row.Cells["Importe"].Value),
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);
// Se actualiza la existencia y el kardex
int iFilaDif = this.dgvDiferencia.EncontrarIndiceDeValor("ParteID", parteId);
AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.EntradaCompra, movimientoEntrada.FolioFactura, iAutorizoID
, this.cboProveedor.Text, proveedorId.ToString(), this.cboUbicacionDestino.Text, cantidad
, Util.Decimal(this.dgvDiferencia["Costo Nuevo", iFilaDif].Value)
, Cat.Tablas.MovimientoInventario, movimientoEntrada.MovimientoInventarioID);
var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoEntrada.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.Decimal(oExistencia.Existencia - cantidad),
ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
/*
var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
if (!oParte.EsServicio.Valor())
{
var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
if (existencia != null)
{
var inicial = existencia.Existencia;
existencia.Existencia += cantidad;
// Datos.Guardar<ParteExistencia>(existencia);
AdmonProc.AgregarExistencia(parteId, sucursalId, cantidad, Cat.Tablas.MovimientoInventario, movimientoEntrada.MovimientoInventarioID);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoEntrada.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.ConvertirDecimal(inicial),
ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
}
}
// Se agrega al Kardex
int iFilaDif = this.dgvDiferencia.EncontrarIndiceDeValor("ParteID", parteId);
AdmonProc.RegistrarKardex(new ParteKardex()
{
ParteID = parteId,
OperacionID = Cat.OperacionesKardex.EntradaCompra,
SucursalID = sucursalId,
Folio = movimientoEntrada.FolioFactura,
Fecha = DateTime.Now,
RealizoUsuarioID = iAutorizoID,
Entidad = this.cboProveedor.Text,
Origen = proveedorId.ToString(),
Destino = this.cboUbicacionDestino.Text,
Cantidad = cantidad,
Importe = Util.ConvertirDecimal(this.dgvDiferencia["Costo Nuevo", iFilaDif].Value),
RelacionTabla = Cat.Tablas.MovimientoInventario,
RelacionID = movimientoEntrada.MovimientoInventarioID
});
*/
// Se afectan los datos del pedido, si aplica
// if (this.dgvDetalleCaptura.Tag != null)
if (this.iCompraDePedidoID > 0)
{
int iPedidoID = this.iCompraDePedidoID; // Util.ConvertirEntero(this.dgvDetalleCaptura.Tag);
var oPartesPed = Datos.GetListOf<PedidoDetalle>(c => c.PedidoID == iPedidoID && c.PedidoEstatusID == Cat.PedidosEstatus.NoSurtido
&& c.Estatus);
var oPartePed = oPartesPed.FirstOrDefault(c => c.ParteID == parteId);
if (oPartePed != null)
{
oPartePed.PedidoEstatusID = Cat.PedidosEstatus.Surtido;
Datos.Guardar<PedidoDetalle>(oPartePed);
// Se verifica si ya no quedan pedidos pendientes, para marcar como Surtido
if (oPartesPed.Count == 1)
{
var oPedido = Datos.GetEntity<Pedido>(c => c.PedidoID == oPartePed.PedidoID && c.Estatus);
oPedido.PedidoEstatusID = Cat.PedidosEstatus.Surtido;
Datos.Guardar<Pedido>(oPedido);
}
}
}
}
// Para limpiar el estatus de relación con un pedido
// this.dgvDetalleCaptura.Tag = null;
this.iCompraDePedidoID = 0;
//Insertar MovimientoDescuentos
foreach (DataGridViewRow row in this.dgvHistorialDescuentos.Rows)
{
int tipoDescuento = Util.Entero(row.Cells["TipoDescuento"].Value);
int tipoDescuentoId = 1;
switch (tipoDescuento)
{
case -1: tipoDescuentoId = 2; break;
case 2: tipoDescuentoId = 3; break;
case 3: tipoDescuentoId = 4; break;
case -2: tipoDescuentoId = 5; break;
case -3: tipoDescuentoId = Cat.TiposDeDescuentoCompras.IndividualAFactura; break;
}
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var hisDesc = new MovimientoInventarioDescuento()
{
MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
ParteID = parteId,
TipoDescuentoID = tipoDescuentoId,
DescuentoUno = Util.Decimal(row.Cells["DescuentoUno"].Value),
DescuentoDos = Util.Decimal(row.Cells["DescuentoDos"].Value),
DescuentoTres = Util.Decimal(row.Cells["DescuentoTres"].Value),
DescuentoCuatro = Util.Decimal(row.Cells["DescuentoCuatro"].Value),
DescuentoCinco = Util.Decimal(row.Cells["DescuentoCinco"].Value)
};
Datos.Guardar<MovimientoInventarioDescuento>(hisDesc);
}
//Actualizar PartePrecio
foreach (DataGridViewRow row in this.dgvDiferencia.Rows)
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var partePrecio = Datos.GetEntity<PartePrecio>(p => p.ParteID.Equals(parteId));
var oPartePrecioAnt = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
var costoNuevo = Util.Decimal(row.Cells["Costo Nuevo"].Value);
var costoActual = Util.Decimal(row.Cells["Costo Actual"].Value);
decimal costoConDescuento = 0;
if (partePrecio != null)
{
if (Convert.ToBoolean(row.Cells["X"].Value).Equals(true))
partePrecio.Costo = costoNuevo;
else
partePrecio.Costo = costoActual;
partePrecio.PorcentajeUtilidadUno = Util.Decimal(row.Cells["%1"].Value);
partePrecio.PorcentajeUtilidadDos = Util.Decimal(row.Cells["%2"].Value);
partePrecio.PorcentajeUtilidadTres = Util.Decimal(row.Cells["%3"].Value);
partePrecio.PorcentajeUtilidadCuatro = Util.Decimal(row.Cells["%4"].Value);
partePrecio.PorcentajeUtilidadCinco = Util.Decimal(row.Cells["%5"].Value);
partePrecio.PrecioUno = Util.Decimal(row.Cells["Precio 1"].Value);
partePrecio.PrecioDos = Util.Decimal(row.Cells["Precio 2"].Value);
partePrecio.PrecioTres = Util.Decimal(row.Cells["Precio 3"].Value);
partePrecio.PrecioCuatro = Util.Decimal(row.Cells["Precio 4"].Value);
partePrecio.PrecioCinco = Util.Decimal(row.Cells["Precio 5"].Value);
//CostoConDescuento, calcular el descuento por fila, si existen descuentos a Factura y a Marca Factura
var rowIndex = UtilLocal.findRowIndex(this.dgvDetalleDescuentos, "ParteID", parteId.ToString());
if (rowIndex != -1)
{
costoConDescuento = Util.Decimal(this.dgvDetalleDescuentos.Rows[rowIndex].Cells["CostoConDescuentoNuevo"].Value);
partePrecio.CostoConDescuento = costoConDescuento;
/*
var rowIndexHisAFactura = Util.findRowIndex(this.dgvHistorialDescuentos, "ParteID", "-1");
if (rowIndexHisAFactura != -1)
{
var desUno = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoUno"].Value);
var desDos = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoDos"].Value);
var desTres = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoTres"].Value);
var desCuatro = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoCuatro"].Value);
var desCinco = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAFactura].Cells["DescuentoCinco"].Value);
precioConDescuento = this.calcularDescuento(precioConDescuento, desUno, desDos, desTres, desCuatro, desCinco);
}
var rowIndexHisAMarcaF = -1;
foreach (DataGridViewRow fila in this.dgvHistorialDescuentos.Rows)
{
if (Util.ConvertirEntero(fila.Cells["ParteID"].Value).Equals(parteId) && Util.ConvertirEntero(fila.Cells["TipoDescuento"].Value).Equals(-2))
{
rowIndexHisAMarcaF = fila.Index;
}
}
if (rowIndexHisAMarcaF != -1)
{
var desUno = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoUno"].Value);
var desDos = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoDos"].Value);
var desTres = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoTres"].Value);
var desCuatro = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoCuatro"].Value);
var desCinco = Util.ConvertirDecimal(this.dgvHistorialDescuentos.Rows[rowIndexHisAMarcaF].Cells["DescuentoCinco"].Value);
precioConDescuento = this.calcularDescuento(precioConDescuento, desUno, desDos, desTres, desCuatro, desCinco);
}
partePrecio.CostoConDescuento = precioConDescuento;
*/
}
Datos.Guardar<PartePrecio>(partePrecio);
//Si cambia de el valor del precio entonces
//Actualizar PartePrecioHistorico
if (partePrecio.Costo != oPartePrecioAnt.Costo || partePrecio.CostoConDescuento != oPartePrecioAnt.CostoConDescuento
|| partePrecio.PrecioUno != oPartePrecioAnt.PrecioUno || partePrecio.PrecioDos != oPartePrecioAnt.PrecioDos
|| partePrecio.PrecioDos != oPartePrecioAnt.PrecioDos || partePrecio.PrecioTres != oPartePrecioAnt.PrecioTres
|| partePrecio.PrecioCinco != oPartePrecioAnt.PrecioCinco)
{
var precioHis = new PartePrecioHistorico()
{
ParteID = parteId,
MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
CostoNuevo = costoNuevo,
CostoActual = costoActual,
CostoConDescuento = costoConDescuento,
PorcentajeUtilidadUno = Util.Decimal(row.Cells["%1"].Value),
PorcentajeUtilidadDos = Util.Decimal(row.Cells["%2"].Value),
PorcentajeUtilidadTres = Util.Decimal(row.Cells["%3"].Value),
PorcentajeUtilidadCuatro = Util.Decimal(row.Cells["%4"].Value),
PorcentajeUtilidadCinco = Util.Decimal(row.Cells["%5"].Value),
PrecioUno = Util.Decimal(row.Cells["Precio 1"].Value),
PrecioDos = Util.Decimal(row.Cells["Precio 2"].Value),
PrecioTres = Util.Decimal(row.Cells["Precio 3"].Value),
PrecioCuatro = Util.Decimal(row.Cells["Precio 4"].Value),
PrecioCinco = Util.Decimal(row.Cells["Precio 5"].Value)
};
Datos.Guardar<PartePrecioHistorico>(precioHis);
}
}
//Actualizar MovimientoInventarioEtiqueta
var etiqueta = new MovimientoInventarioEtiqueta()
{
MovimientoInventarioID = movimientoEntrada.MovimientoInventarioID,
ParteID = parteId,
NumeroEtiquetas = Util.Entero(row.Cells["Etiqueta"].Value),
};
Datos.Guardar<MovimientoInventarioEtiqueta>(etiqueta);
}
//Guardar Imagen en Directorio
//Nombre Imagen = MovimientoID_FolioFactura
/* De momento no se usa. Se quitó por incompatiblidad con el parámetro "pathImagenesMovimientos". Moi 07/05/2015
if (this.picBoxImagen.Image != null)
{
var pathProveedor = System.IO.Path.Combine(GlobalClass.ConfiguracionGlobal.pathImagenesMovimientos, "Compras", this.cboProveedor.Text, DateTime.Now.Year.ToString());
if (!System.IO.Directory.Exists(pathProveedor))
System.IO.Directory.CreateDirectory(pathProveedor);
//Guardar Imagen en la tabla
movimientoEntrada.NombreImagen = string.Format("{0}_{1}{2}", movimientoEntrada.MovimientoInventarioID, movimientoEntrada.FolioFactura, ".jpg");
Datos.Guardar<MovimientoInventario>(movimientoEntrada);
var path = System.IO.Path.Combine(pathProveedor, movimientoEntrada.NombreImagen);
picBoxImagen.Image.Save(path, ImageFormat.Jpeg);
} */
// Se manda a afectar contabilidad (AfeConta)
if (this.chkEsNota.Checked)
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.CompraCreditoNota, movimientoEntrada.MovimientoInventarioID
, movimientoEntrada.FolioFactura, this.cboProveedor.Text, sucursalId);
else
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.CompraCreditoFactura, movimientoEntrada.MovimientoInventarioID
, movimientoEntrada.FolioFactura, this.cboProveedor.Text, sucursalId);
SplashScreen.Close();
this.btnFinish.Enabled = true;
this.Cursor = Cursors.Default;
//Visor de ticket de entrada compra
ReporteadorMovimientos visor = ReporteadorMovimientos.Instance;
visor.oID = movimientoEntrada.MovimientoInventarioID;
visor.oTipoReporte = 3;
visor.Load();
var resEtiqueta = Util.MensajePregunta("Desea imprimir las etiquetas?", GlobalClass.NombreApp);
if (resEtiqueta == DialogResult.Yes)
{
//VisorDeReportes visor = VisorDeReportes.Instance;
ReporteadorMovimientos visorEt = ReporteadorMovimientos.Instance;
visorEt.oID = movimientoEntrada.MovimientoInventarioID;
visorEt.oTipoReporte = 2;
visorEt.Load();
}
#endregion
break;
case 2:
#region [ Entrada Inventario ]
//Insertar Movimiento
var movimientoEntradaI = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
ProveedorID = proveedorId,
SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
FechaFactura = this.dtpFechaFacturacion.Value,
FechaRecepcion = this.dtpFechaRecepcion.Value,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
Observacion = this.txtObservaciones.Text,
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar<MovimientoInventario>(movimientoEntradaI);
if (movimientoEntradaI.MovimientoInventarioID < 1)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var cantidad = Util.Decimal(row.Cells["UNS"].Value);
var detalleMovimiento = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
ParteID = parteId,
Cantidad = cantidad,
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);
// Se actualiza la existencia y el kardex
bool bEntradaGarantia = (Util.Entero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.EntradaGarantia);
var oPartePrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.EntradaInventario, movimientoEntradaI.MovimientoInventarioID.ToString(), iAutorizoID
, this.cboConceptoOperacion.Text, (bEntradaGarantia ? "GARANTÍA" : "----"), this.cboUbicacionDestino.Text, cantidad
, oPartePrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.Decimal(oExistencia.Existencia - cantidad),
ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
//Actualizar ParteExistencia
/*
var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
if (!oParte.EsServicio.Valor())
{
var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
if (existencia != null)
{
var inicial = existencia.Existencia;
existencia.Existencia += cantidad;
// Datos.Guardar<ParteExistencia>(existencia);
AdmonProc.AgregarExistencia(parteId, sucursalId, cantidad, Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.ConvertirDecimal(inicial),
ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
}
}
// Se agrega al Kardex
var oPartePrecio = General.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
AdmonProc.RegistrarKardex(new ParteKardex()
{
ParteID = parteId,
OperacionID = Cat.OperacionesKardex.EntradaInventario,
SucursalID = sucursalId,
Folio = movimientoEntradaI.MovimientoInventarioID.ToString(),
Fecha = DateTime.Now,
RealizoUsuarioID = iAutorizoID,
Entidad = "----",
Origen = (bEntradaGarantia ? "GARANTÍA" : "----"),
Destino = this.cboUbicacionDestino.Text,
Cantidad = cantidad,
Importe = oPartePrecio.Costo.Valor(),
RelacionTabla = Cat.Tablas.MovimientoInventario,
RelacionID = movimientoEntradaI.MovimientoInventarioID
});
*/
// Se verifica si es una garantía, para cambiar el estatus correspondiente
if (bEntradaGarantia)
{
int iGarantiaID = Util.Entero(row.Tag);
var oGarantia = Datos.GetEntity<VentaGarantia>(c => c.VentaGarantiaID == iGarantiaID && c.Estatus);
if (oGarantia != null)
{
oGarantia.RespuestaID = Cat.VentasGarantiasRespuestas.ArticuloNuevo;
if (oGarantia.AccionID == Cat.VentasGarantiasAcciones.RevisionDeProveedor)
{
oGarantia.EstatusGenericoID = Cat.EstatusGenericos.Resuelto;
}
else
{
oGarantia.FechaCompletado = DateTime.Now;
oGarantia.EstatusGenericoID = Cat.EstatusGenericos.Completada;
}
Datos.Guardar<VentaGarantia>(oGarantia);
}
}
}
// Se manda a afectar contabilidad (AfeConta)
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.EntradaInventario, movimientoEntradaI.MovimientoInventarioID
, ResU.Respuesta.NombreUsuario, movimientoEntradaI.Observacion, sucursalId);
SplashScreen.Close();
this.btnFinish.Enabled = true;
this.Cursor = Cursors.Default;
//Visor de ticket de entrada compra
ReporteadorMovimientos visorE = ReporteadorMovimientos.Instance;
visorE.oID = movimientoEntradaI.MovimientoInventarioID;
visorE.oTipoReporte = 4;
visorE.Load();
#endregion
break;
case 3:
#region [ Salida Inventario ]
//Valida la existencia antes de dar de baja del inventario
bool bError = false;
foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var cantidad = Util.Decimal(row.Cells["UNS"].Value);
var existencia = Datos.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId && p.Estatus);
if (existencia.Existencia < cantidad)
{
row.ErrorText = string.Format("No hay existencia suficiente. Existencia: {0}, Salida: {1}", existencia.Existencia, cantidad);
row.DefaultCellStyle.ForeColor = Color.Red;
bError = true;
}
}
if (bError)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
UtilLocal.MensajeAdvertencia("Uno o más artículos no cuentan con existencia suficiente para la salida. No se puede continuar.");
this.btnFinish.Enabled = true;
return;
}
//Insertar Movimiento
var movimientoSalida = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
ProveedorID = proveedorId,
SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
FechaFactura = this.dtpFechaFacturacion.Value,
FechaRecepcion = this.dtpFechaRecepcion.Value,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
Observacion = this.txtObservaciones.Text,
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar<MovimientoInventario>(movimientoSalida);
if (movimientoSalida.MovimientoInventarioID < 1)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var cantidad = Util.Decimal(row.Cells["UNS"].Value);
var detalleMovimiento = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
ParteID = parteId,
Cantidad = cantidad,
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);
// Se actualiza la existencia y el kardex
var oPartePrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.SalidaInventario
, movimientoSalida.MovimientoInventarioID.ToString(), iAutorizoID, this.cboConceptoOperacion.Text, "----", this.cboUbicacionDestino.Text
, (cantidad * -1), oPartePrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoSalida.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.Decimal(oExistencia.Existencia + cantidad),
ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
//Actualizar ParteExistencia
/*
var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
if (!oParte.EsServicio.Valor())
{
var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
if (existencia != null)
{
var inicial = existencia.Existencia;
existencia.Existencia -= cantidad;
// Datos.Guardar<ParteExistencia>(existencia);
AdmonProc.AgregarExistencia(parteId, sucursalId, (cantidad * -1), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoSalida.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.ConvertirDecimal(inicial),
ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
}
}
// Se agrega al Kardex
var oPartePrecio = General.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
AdmonProc.RegistrarKardex(new ParteKardex()
{
ParteID = parteId,
OperacionID = Cat.OperacionesKardex.SalidaInventario,
SucursalID = sucursalId,
Folio = movimientoSalida.MovimientoInventarioID.ToString(),
Fecha = DateTime.Now,
RealizoUsuarioID = iAutorizoID,
Entidad = "----",
Origen = "----",
Destino = this.cboUbicacionDestino.Text,
Cantidad = cantidad,
Importe = oPartePrecio.Costo.Valor(),
RelacionTabla = Cat.Tablas.MovimientoInventario,
RelacionID = movimientoSalida.MovimientoInventarioID
});
*/
}
// Se manda a afectar contabilidad (AfeConta)
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.SalidaInventario, movimientoSalida.MovimientoInventarioID
, ResU.Respuesta.NombreUsuario, movimientoSalida.Observacion, sucursalId);
SplashScreen.Close();
this.btnFinish.Enabled = true;
this.Cursor = Cursors.Default;
//Visor de ticket de entrada compra
ReporteadorMovimientos visorS = ReporteadorMovimientos.Instance;
visorS.oID = movimientoSalida.MovimientoInventarioID;
visorS.oTipoReporte = 5;
visorS.Load();
#endregion
break;
case 4:
#region [ Devolucion ]
// Se obtiene el movimiento fuente (la compra a la cual se le aplica la devolución / garantía)
int iFuenteMovDetID = Util.Entero(this.dgvDetalleCaptura["FuenteMovimientoInventarioDetalleID", 0].Value);
var oFuenteMovDet = Datos.GetEntity<MovimientoInventarioDetalle>(c => c.MovimientoInventarioDetalleID == iFuenteMovDetID && c.Estatus);
var oFuenteMov = Datos.GetEntity<MovimientoInventario>(c => c.MovimientoInventarioID == oFuenteMovDet.MovimientoInventarioID && c.Estatus);
//Validaciones
foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
{
if (Util.Entero(this.cboConceptoOperacion.SelectedValue) != Cat.MovimientosConceptosDeOperacion.DevolucionGarantia)
{
//Valida existencias antes de continuar
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var sucursal = Util.Entero(this.cboUbicacionDestino.SelectedValue);
var unidades = Util.Decimal(row.Cells["UNS"].Value);
var existencias = Datos.GetEntity<ParteExistencia>(p => p.ParteID.Equals(parteId) && p.SucursalID.Equals(sucursal) && p.Estatus);
if (existencias.Existencia < unidades)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
Util.MensajeError(string.Format("{0} {1} {2}", "El articulo", row.Cells["Numero Parte"].Value, "no cuenta con la existencia suficiente para realizar la operación"), GlobalClass.NombreApp);
return;
}
}
//Valida que la cantidad a devolver sea igual o menor a la del movimiento
//if (movimientoInventario.MovimientoInventarioID > 0)
//{
// var detalle = General.GetEntity<MovimientoInventarioDetalle>(m => m.MovimientoInventarioID.Equals(movimientoInventario.MovimientoInventarioID)
// && m.ParteID.Equals(parteId) && m.Estatus);
// if (unidades > detalle.Cantidad)
// {
// this.Cursor = Cursors.Default;
// SplashScreen.Close();
// Util.MensajeError(string.Format("{0} {1} {2}", "El articulo", row.Cells["Numero Parte"].Value, "tiene registrada una cantidad menor a la que intenta devolver."), GlobalClass.NombreApp);
// return;
// }
//}
//Validar que LA CANTIDAD del movimiento de compra, sea menor o igual que la suma de las devoluciones
/*
var mov = General.GetEntity<MovimientoInventarioView>(m => m.MovimientoInventarioID == movimientoInventario.MovimientoInventarioID && m.FolioFactura == m.FolioFactura);
if (mov != null)
{
var det = General.GetEntity<MovimientoInventarioDetalleView>(m => m.MovimientoInventarioID == mov.MovimientoInventarioID && m.ParteID == parteId);
if (det != null)
{
var dev = General.GetEntity<MovimientosInventarioContadorDevolucionesView>(m => m.MovimientoInventarioID == movimientoInventario.MovimientoInventarioID
&& m.ParteID == parteId);
if (dev != null)
{
if (det.Cantidad > dev.Cantidad)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
Util.MensajeError(string.Format("{0} {1} {2}", "El articulo", row.Cells["Numero Parte"].Value, "tiene registrada una cantidad menor en la Factura a la que intenta devolver."), GlobalClass.NombreApp);
return;
}
}
}
else
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
Util.MensajeError("Error al tratar de validar la cantidad comprada.", GlobalClass.NombreApp);
return;
}
}
else
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
Util.MensajeError("Error al tratar de validar el movmiento de Compra.", GlobalClass.NombreApp);
return;
}
*/
decimal mCantidad = Util.Decimal(row.Cells["UNS"].Value);
if (oFuenteMovDet != null && (oFuenteMovDet.Cantidad - oFuenteMovDet.CantidadDevuelta) < mCantidad)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
UtilLocal.MensajeAdvertencia(string.Format("El artículo {0} tiene registrada una cantidad menor en la factura a la que intenta devolver."
, row.Cells["Numero Parte"].Value));
return;
}
}
// Se obtiene el folio factura del primer artículo a devolver
if (this.dgvDetalleCaptura.Rows.Count > 0)
{
this.txtFolioFactura.Text = oFuenteMov.FolioFactura;
}
//Insertar Movimiento
var movimientoDevolucion = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = Util.Entero(this.cboTipoPago.SelectedValue),
ProveedorID = proveedorId,
SucursalOrigenID = Util.Entero(this.cboUbicacionOrigen.SelectedValue),
SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
FechaFactura = this.dtpFechaFacturacion.Value,
FechaRecepcion = this.dtpFechaRecepcion.Value,
FolioFactura = this.txtFolioFactura.Text,
Subtotal = null,
IVA = null,
ImporteTotal = Util.Decimal(this.lblTotal.Text),
FueLiquidado = false,
TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
Observacion = this.txtObservaciones.Text,
Articulos = Util.Decimal(this.txtArticulos.Text),
Unidades = Util.Decimal(this.lblUnidades.Text),
Seguro = null,
ImporteTotalSinDescuento = null,
DeMovimientoInventarioID = oFuenteMov.MovimientoInventarioID
};
Datos.Guardar<MovimientoInventario>(movimientoDevolucion);
if (movimientoDevolucion.MovimientoInventarioID < 1)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
foreach (DataGridViewRow row in this.dgvDetalleCaptura.Rows)
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var cantidad = Util.Decimal(row.Cells["UNS"].Value);
var detalleMovimiento = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoDevolucion.MovimientoInventarioID,
ParteID = parteId,
Cantidad = cantidad,
PrecioUnitario = Util.Decimal(row.Cells["Costo Inicial"].Value),
Importe = Util.Decimal(row.Cells["Importe"].Value),
FueDevolucion = true,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);
// Se actualiza la existencia y el kardex
bool bDevGarantia = (Util.Entero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.DevolucionGarantia);
// Si no es de garantía, igual se mete un registro de existencia pero en cero, sólo para que quede el dato del movimiento que se hizo
AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.DevolucionAProveedor,
movimientoDevolucion.MovimientoInventarioID.ToString(), iAutorizoID, this.cboProveedor.Text, this.cboUbicacionDestino.Text
, this.cboConceptoOperacion.Text, (bDevGarantia ? 0 : (cantidad * -1))
, Util.Decimal(row.Cells["Costo Inicial"].Value), Cat.Tablas.MovimientoInventario, movimientoDevolucion.MovimientoInventarioID);
var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoDevolucion.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.Decimal(oExistencia.Existencia + cantidad),
ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
SucursalID = Util.Entero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
//Actualizar ParteExistencia, si no es garantía y no es servicio
/*
bool bDevGarantia = (Util.ConvertirEntero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.DevolucionGarantia);
var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
if (!oParte.EsServicio.Valor() && !bDevGarantia) {
var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
if (existencia != null)
{
var inicial = existencia.Existencia;
existencia.Existencia -= cantidad;
// Datos.Guardar<ParteExistencia>(existencia);
AdmonProc.AgregarExistencia(parteId, sucursalId, (cantidad * -1), Cat.Tablas.MovimientoInventario
, movimientoDevolucion.MovimientoInventarioID);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = movimientoDevolucion.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.ConvertirDecimal(inicial),
ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
SucursalID = Util.ConvertirEntero(this.cboUbicacionDestino.SelectedValue)
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
}
}
// Se agrega al Kardex
AdmonProc.RegistrarKardex(new ParteKardex()
{
ParteID = parteId,
OperacionID = Cat.OperacionesKardex.DevolucionAProveedor,
SucursalID = sucursalId,
Folio = movimientoDevolucion.MovimientoInventarioID.ToString(),
Fecha = DateTime.Now,
RealizoUsuarioID = iAutorizoID,
Entidad = this.cboProveedor.Text,
Origen = this.cboUbicacionDestino.Text,
Destino = (bDevGarantia ? "GARANTÍA" : proveedorId.ToString()),
Cantidad = (bDevGarantia ? 0 : cantidad),
Importe = Util.ConvertirDecimal(row.Cells["Costo Inicial"].Value),
RelacionTabla = Cat.Tablas.MovimientoInventario,
RelacionID = movimientoDevolucion.MovimientoInventarioID
});
*/
// Se modifica la cantidad devuelta, en el detalle de la compra utilizada
if (oFuenteMovDet != null)
{
oFuenteMovDet.CantidadDevuelta += cantidad;
Datos.Guardar<MovimientoInventarioDetalle>(oFuenteMovDet);
}
// Se verifica si es una garantía, para cambiar el estatus correspondiente, y relacionar la garantía con el Mov
if (Util.Entero(this.cboConceptoOperacion.SelectedValue) == Cat.MovimientosConceptosDeOperacion.DevolucionGarantia)
{
int iGarantiaID = Util.Entero(row.Tag);
var oGarantia = Datos.GetEntity<VentaGarantia>(c => c.VentaGarantiaID == iGarantiaID && c.Estatus);
if (oGarantia != null)
{
oGarantia.EstatusGenericoID = Cat.EstatusGenericos.EnRevision;
oGarantia.MovimientoInventarioID = oFuenteMov.MovimientoInventarioID;
Datos.Guardar<VentaGarantia>(oGarantia);
}
}
}
SplashScreen.Close();
this.btnFinish.Enabled = true;
this.Cursor = Cursors.Default;
//Visor de ticket de devolucion
ReporteadorMovimientos visorD = ReporteadorMovimientos.Instance;
visorD.oID = movimientoDevolucion.MovimientoInventarioID;
visorD.oTipoReporte = 6;
visorD.Load();
#endregion
break;
default:
break;
}
new Notificacion(string.Format("{0} {1}", this.cboTipoOperacion.Text, "Guardado exitosamente"), 2 * 1000).Mostrar(Principal.Instance);
this.finalizar();
}
catch (Exception ex)
{
SplashScreen.Close();
this.btnFinish.Enabled = true;
this.Cursor = Cursors.Default;
UtilLocal.MensajeError(ex.MensajeDeError());
}
}
private void btnProcesar_Click(object sender, EventArgs e)
{
try
{
int iAutorizoID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
if (ResU.Exito)
iAutorizoID = ResU.Respuesta.UsuarioID;
else
{
Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
return;
}
var res = Util.MensajePregunta("¿Está seguro de que la información es correcta?", GlobalClass.NombreApp);
if (res == DialogResult.No)
return;
if (this.dgvTraspasos.Rows.Count <= 0)
{
Util.MensajeError("Debe seleccionar al menos un articulo.", GlobalClass.NombreApp);
return;
}
this.Cursor = Cursors.WaitCursor;
SplashScreen.Show(new Splash());
this.btnProcesar.Enabled = false;
var sucursalId = Util.Entero(this.cboUbicacionOrigen.SelectedValue);
decimal unidades = 0;
//Validar que la cantidad de cualquier fila sea mayor a 0
foreach (DataGridViewRow row in this.dgvTraspasos.Rows)
{
var cantidad = Util.Decimal(row.Cells["Cantidad"].Value);
if (cantidad <= 0)
{
Util.MensajeError(string.Format("{0} {1} {2}", "No puede traspasar el Número de Parte:", Util.Cadena(row.Cells["Numero Parte"].Value), "con cantidad en 0."), GlobalClass.NombreApp);
this.Cursor = Cursors.Default;
return;
}
}
//Validar existencias de cada articulo en la sucursal origen
foreach (DataGridViewRow row in this.dgvTraspasos.Rows)
{
if (Util.Logico(row.Cells["X"].Value).Equals(true))
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var cantidad = Util.Decimal(row.Cells["Cantidad"].Value);
unidades += cantidad;
var parteExistencia = Datos.GetEntity<ParteExistencia>(p => p.ParteID.Equals(parteId) && p.SucursalID.Equals(sucursalId) && p.Estatus);
if (null != parteExistencia)
{
if (parteExistencia.Existencia <= 0 || cantidad > parteExistencia.Existencia)
{
Util.MensajeError(string.Format("{0}{1}", row.Cells["Numero Parte"].Value, " No cuenta con la existencia suficiente en este momento."), GlobalClass.NombreApp);
this.Cursor = Cursors.Default;
SplashScreen.Close();
this.btnProcesar.Enabled = true;
this.dgvTraspasos.Select();
row.Cells["Cantidad"].Selected = true;
return;
}
}
}
}
//Almacenar traspaso
var traspaso = new MovimientoInventario()
{
TipoOperacionID = 5,
SucursalOrigenID = sucursalId,
SucursalDestinoID = Util.Entero(this.cboUbicacionDestino.SelectedValue),
Unidades = unidades,
ImporteTotal = 0,
FueLiquidado = false,
UsuarioSolicitoTraspasoID = Util.Entero(this.cboSolicito.SelectedValue),
ExisteContingencia = false,
UsuarioID = iAutorizoID,
FechaRegistro = DateTime.Now,
Estatus = true,
Actualizar = true
};
Datos.SaveOrUpdate<MovimientoInventario>(traspaso);
//Almacenar el detalle del traspaso
if (traspaso.MovimientoInventarioID > 0)
{
decimal mCostoTotal = 0;
foreach (DataGridViewRow row in this.dgvTraspasos.Rows)
{
if (Util.Logico(row.Cells["X"].Value).Equals(true))
{
var parteId = Util.Entero(row.Cells["ParteID"].Value);
var cantidad = Util.Decimal(row.Cells["Cantidad"].Value);
var detalleTraspaso = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = traspaso.MovimientoInventarioID,
ParteID = parteId,
Cantidad = cantidad,
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleTraspaso);
// Se actualiza la existencia y el kardex
var oPartePrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
AdmonProc.AfectarExistenciaYKardex(parteId, sucursalId, Cat.OperacionesKardex.SalidaTraspaso, traspaso.MovimientoInventarioID.ToString()
, iAutorizoID, this.cboProveedor.Text, this.cboUbicacionOrigen.Text, this.cboUbicacionDestino.Text, (cantidad * -1)
, oPartePrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, traspaso.MovimientoInventarioID);
var oExistencia = Datos.GetEntity<ParteExistencia>(c => c.ParteID == parteId && c.SucursalID == sucursalId && c.Estatus);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = traspaso.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.Decimal(oExistencia.Existencia + cantidad),
ExistenciaFinal = Util.Decimal(oExistencia.Existencia),
SucursalID = sucursalId
};
Datos.Guardar<MovimientoInventarioHistorial>(historial);
//Descontar la existencia actual de la sucursal origen
/*
var oParte = General.GetEntity<Parte>(c => c.ParteID == parteId && c.Estatus);
if (!oParte.EsServicio.Valor())
{
var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == parteId && p.SucursalID == sucursalId);
if (existencia != null)
{
var inicial = existencia.Existencia;
existencia.Existencia -= cantidad;
existencia.UsuarioID = iAutorizoID;
// existencia.FechaModificacion = DateTime.Now;
// General.SaveOrUpdate<ParteExistencia>(existencia, existencia);
AdmonProc.AgregarExistencia(parteId, sucursalId, (cantidad * -1), Cat.Tablas.MovimientoInventario, traspaso.MovimientoInventarioID);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = traspaso.MovimientoInventarioID,
ParteID = parteId,
ExistenciaInicial = Util.ConvertirDecimal(inicial),
ExistenciaFinal = Util.ConvertirDecimal(existencia.Existencia),
SucursalID = sucursalId,
UsuarioID = iAutorizoID,
FechaRegistro = DateTime.Now,
Estatus = true,
Actualizar = true
};
General.SaveOrUpdate<MovimientoInventarioHistorial>(historial, historial);
}
}
// Se agrega al Kardex
var oPartePrecio = General.GetEntity<PartePrecio>(c => c.ParteID == parteId && c.Estatus);
AdmonProc.RegistrarKardex(new ParteKardex()
{
ParteID = parteId,
OperacionID = Cat.OperacionesKardex.SalidaTraspaso,
SucursalID = sucursalId,
Folio = traspaso.MovimientoInventarioID.ToString(),
Fecha = DateTime.Now,
RealizoUsuarioID = iAutorizoID,
Entidad = this.cboProveedor.Text,
Origen = this.cboUbicacionOrigen.Text,
Destino = this.cboUbicacionDestino.Text,
Cantidad = cantidad,
Importe = oPartePrecio.Costo.Valor(),
RelacionTabla = Cat.Tablas.MovimientoInventario,
RelacionID = traspaso.MovimientoInventarioID
});
*/
// Se suma el importe de cada parte, para crear la póliza
mCostoTotal += (oPartePrecio.Costo.Valor() * cantidad);
}
}
// Se genera la póliza especial correspondiente (AfeConta)
var oPoliza = ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Diario, string.Format("TRASPASO ORIGEN {0:00} DESTINO {1:00}",
this.cboUbicacionOrigen.SelectedValue, this.cboUbicacionDestino.SelectedValue), Cat.ContaCuentasAuxiliares.Inventario
, Cat.ContaCuentasAuxiliares.Inventario, mCostoTotal, traspaso.MovimientoInventarioID.ToString()
, Cat.Tablas.MovimientoInventario, traspaso.MovimientoInventarioID, Util.Entero(this.cboUbicacionOrigen.SelectedValue));
var oCuentaQuitar = Datos.GetEntity<ContaPolizaDetalle>(c => c.ContaPolizaID == oPoliza.ContaPolizaID && c.Cargo > 0);
if (oCuentaQuitar != null)
{
oCuentaQuitar.Cargo = 0;
Datos.Guardar<ContaPolizaDetalle>(oCuentaQuitar);
}
}
//Visor de ticket de traspaso
ReporteadorMovimientos visor = ReporteadorMovimientos.Instance;
visor.oID = traspaso.MovimientoInventarioID;
visor.oTipoReporte = 7;
visor.Load();
this.LimpiarFormulario();
this.Cursor = Cursors.Default;
SplashScreen.Close();
this.btnProcesar.Enabled = true;
new Notificacion("Traspaso Guardado exitosamente", 2 * 1000).Mostrar(Principal.Instance);
}
catch (Exception ex)
{
this.Cursor = Cursors.Default;
SplashScreen.Close();
this.btnProcesar.Enabled = true;
Util.MensajeError(ex.Message, GlobalClass.NombreApp);
}
}
public ActionResult <MovimientoInventario> Create([FromBody] MovimientoInventario movimiento)
{
_movimientoInventarioService.Create(movimiento);
return(CreatedAtRoute("GetMovimientoInventario", new { id = movimiento.Id.ToString() }, movimiento));
}
public async Task <ActionResult <MovimientoInventario> > PostMovimientoInventario(MovimientoInventario movimientoInventario)
{
try
{
if (movimientoInventario.InventarioId == 0)
{
movimientoInventario.Inventario.Deposito = null;
movimientoInventario.Inventario.ProductoPresentacion = null;
_context.inventario.Add(movimientoInventario.Inventario);
await _context.SaveChangesAsync();
movimientoInventario.InventarioId = movimientoInventario.Inventario.Id;
}
Inventario inventarioDb = await _context.inventario.FirstAsync(x => x.Id == movimientoInventario.InventarioId);
if (movimientoInventario.entra)
{
inventarioDb.cantidadUnidadesEnExistencia += movimientoInventario.cantidadUnidadesMovida;
}
else if (movimientoInventario.sale)
{
inventarioDb.cantidadUnidadesEnExistencia -= movimientoInventario.cantidadUnidadesMovida;
}
movimientoInventario.Inventario = null;
_context.Entry(inventarioDb).State = EntityState.Modified;
_context.movimientoInventario.Add(movimientoInventario);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetMovimientoInventario", new { id = movimientoInventario.Id }, movimientoInventario));
}
catch (Exception ex)
{
throw;
}
}
public MovimientoInventario Create(MovimientoInventario movimiento)
{
_movimientoInventario.InsertOne(movimiento);
return(movimiento);
}
public void Update(string id, MovimientoInventario movimiento) => _movimientoInventario.ReplaceOne(mov => mov.Id == id, movimiento);
public IActionResult IngresoMateriaPrima(MovimientoInventario movimientoInventario)
{
if (ModelState.IsValid)
{
List <MovimientoInventario> listMov = new List <MovimientoInventario>();
if (User.Identity.IsAuthenticated)
{
movimientoInventario.Digitador = User.FindFirst(ClaimTypes.NameIdentifier).Value;
movimientoInventario.FechaDigitador = DateTime.Now;
}
var detalleOrdenAprov = _context.DetalleAprovisionamiento
.Include(j => j.InventarioFkNavigation)
.Where(i => i.OrdenAprovisionamientoFk == movimientoInventario.OrdenAprovisionamientoFk).ToList();
Random ran = new Random();
var aumentar = _context.Inventario.ToList();
foreach (var item in detalleOrdenAprov)
{
listMov.Add(new MovimientoInventario()
{
Cantidad = item.Cantidad,
PrecioUnitario = ran.Next(20, 100),
Digitador = movimientoInventario.Digitador,
FechaDigitador = movimientoInventario.FechaDigitador,
FechaMovimiento = DateTime.Now,
Factura = ran.Next(20, 100).ToString(),
Observacion = movimientoInventario.Observacion,
OrdenAprovisionamientoFk = movimientoInventario.OrdenAprovisionamientoFk,
ProveedorFk = movimientoInventario.ProveedorFk,
TipoMovimiento = "I",
InventarioFk = item.InventarioFk
});
item.InventarioFkNavigation.Total = item.InventarioFkNavigation.Total + item.Cantidad;
}
var ordenAp = _context.OrdenAprovisionamiento.Find(movimientoInventario.OrdenAprovisionamientoFk);
var ListDet = _context.DetalleAprovisionamiento.Where(i => i.OrdenAprovisionamientoFk == movimientoInventario.OrdenAprovisionamientoFk).ToList();
//var ListDetalle = _context.DetalleAprovisionamiento.ToList();
foreach (var item in ListDet)
{
item.Ingresado = true;
}
ordenAp.FechaEntrega = DateTime.Now;
ordenAp.EstadoEntregado = true;
foreach (var item in listMov)
{
_context.Add(item);
}
// movimientoInventario.Cantidad
// _context.Add(movimientoInventario);
_context.SaveChanges();
return(RedirectToAction(nameof(Index)));
}
ViewData["ProveedorFk"] = new SelectList(_context.Proveedor, "NumeroProveedor", "NombreProveedor");
ViewData["OrdenAprovisionamientoFk"] = new SelectList(_context.OrdenAprovisionamiento.Where(i => i.EstadoEntregado == false), "NumeroOrdenAprovisionamiento", "FechaEstimadaEntrega");
// return View(inventario);
return(View());
}
private void AgruparMovimientos()
{
// Se valida que haya un proveedor seleccionado
if (this.Proveedor.ProveedorID <= 0)
{
UtilLocal.MensajeAdvertencia("No hay ningún proveedor seleccionado. No se puede continuar.");
return;
}
var oMovsSel = new List<int>();
foreach (DataGridViewRow oFila in this.dgvMovimientosNoPagados.Rows)
{
if (!Util.Logico(oFila.Cells["pen_Sel"].Value))
continue;
// Se valida que no se seleccione un movimiento agrupador
if (Util.Logico(oFila.Cells["pen_EsAgrupador"].Value))
{
UtilLocal.MensajeAdvertencia("No se puede agrupar un movimiento que ya es agrupador.");
return;
}
//
if (Util.Logico(oFila.Cells["pen_Sel"].Value))
oMovsSel.Add(Util.Entero(oFila.Cells["pen_MovimientoInventarioID"].Value));
}
if (oMovsSel.Count <= 0)
{
UtilLocal.MensajeAdvertencia("No hay movimientos seleccionados para agrupar.");
return;
}
var frmAgrupar = new MovimientosAgrupar(oMovsSel);
if (frmAgrupar.ShowDialog(Principal.Instance) == DialogResult.OK)
{
Cargando.Mostrar();
// Se obtienen los movimientos a agrupar
var oMovsAgr = new List<MovimientoInventario>();
foreach (int iMovID in oMovsSel)
oMovsAgr.Add(Datos.GetEntity<MovimientoInventario>(c => c.MovimientoInventarioID == iMovID && c.Estatus));
// Se crea el movimiento agrupador
var oMovAgr = new MovimientoInventario()
{
TipoOperacionID = Cat.TiposDeOperacionMovimientos.EntradaCompra,
ProveedorID = this.Proveedor.ProveedorID,
FechaRecepcion = frmAgrupar.FechaGuardar,
Subtotal = oMovsAgr.Sum(c => c.Subtotal),
IVA = oMovsAgr.Sum(c => c.IVA),
ImporteTotal = oMovsAgr.Sum(c => c.ImporteTotal),
FueLiquidado = false,
ImporteFactura = oMovsAgr.Sum(c => c.ImporteFactura),
EsAgrupador = true
};
Datos.Guardar<MovimientoInventario>(oMovAgr);
// Se hace la agrupación
foreach (var oReg in oMovsAgr)
{
oReg.MovimientoAgrupadorID = oMovAgr.MovimientoInventarioID;
Datos.Guardar<MovimientoInventario>(oReg);
}
Cargando.Cerrar();
this.CargarMovimientosNoPagados(this.Proveedor.ProveedorID);
}
frmAgrupar.Dispose();
}
public void Remove(MovimientoInventario movimiento) => _movimientoInventario.DeleteOne(mov => mov.Id == movimiento.Id);
protected override void btnGuardar_Click(object sender, EventArgs e)
{
try
{
if (!Validaciones())
return;
if (EsNuevo)
{
}
else
{
int iAutorizoID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
if (ResU.Exito)
iAutorizoID = ResU.Respuesta.UsuarioID;
else
{
Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
return;
}
SplashScreen.Show(new Splash());
this.btnGuardar.Enabled = false;
var ContingenciaCompleta = Datos.GetEntity<MovimientoInventarioContingenciasView>(c => c.MovimientoInventarioTraspasoContingenciaID == Contingencia.MovimientoInventarioTraspasoContingenciaID);
if (null == ContingenciaCompleta)
return;
//Actualiza la contingencia
Contingencia.FechaModificacion = DateTime.Now;
Contingencia.MovimientoInventarioEstatusContingenciaID = 1;
Contingencia.UsuarioID = GlobalClass.UsuarioGlobal.UsuarioID;
Contingencia.UsuarioSolucionoID = GlobalClass.UsuarioGlobal.UsuarioID;
Contingencia.FechaSoluciono = DateTime.Now;
Contingencia.TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue);
Contingencia.TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue);
Contingencia.ObservacionSolucion = this.txtObservacion.Text;
if (Util.Entero(this.cboTipoOperacion.SelectedValue) == Cat.TiposDeOperacionMovimientos.SalidaInventario)
Contingencia.ObservacionSolucion += (" - SE CREA UNA ENTRADA PARA DEVOLVER EL TRASPASO A LA TIENDA ORIGEN Y EN EL SEGUNDO MOVIMIENTO UNA SALIDA PARA PODER HACER LA SALIDA DEL INVENTARIO");
Contingencia.FechaModificacion = DateTime.Now;
Datos.SaveOrUpdate<MovimientoInventarioTraspasoContingencia>(Contingencia);
int iSucursalID = ContingenciaCompleta.SucursalOrigenID.Valor();
string sOrigen = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalOrigenID.Valor());
string sDestino = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalDestinoID.Valor());
var oPrecio = Datos.GetEntity<PartePrecio>(c => c.ParteID == ContingenciaCompleta.ParteID && c.Estatus);
switch (Util.Entero(cboTipoOperacion.SelectedValue))
{
case 2:
#region [ Entrada Inventario ]
//Insertar Movimiento
var movimientoEntradaI = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = 1,
ProveedorID = 1,
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
FechaFactura = DateTime.Now,
FechaRecepcion = DateTime.Now,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = ContingenciaCompleta.TipoConceptoOperacionID,
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar<MovimientoInventario>(movimientoEntradaI);
if (movimientoEntradaI.MovimientoInventarioID < 1)
{
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
var detalleMovimiento = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimiento);
//Actualizar ParteExistencia
/* var sucursalId = ContingenciaCompleta.SucursalOrigenID;
var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == ContingenciaCompleta.ParteID && p.SucursalID == sucursalId);
if (existencia != null)
{
existencia.Existencia += Util.ConvertirDecimal(ContingenciaCompleta.Diferencia);
Datos.Guardar<ParteExistencia>(existencia);//dmod
}
*/
// AdmonProc.AgregarExistencia(ContingenciaCompleta.ParteID, sucursalId.Valor(), ContingenciaCompleta.Diferencia.Valor()
// , Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
// Se modifica la existencia y el kardex
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Entrada"
, sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
#endregion
break;
case 3:
#region [ Salida Inventario ]
//Insertar Movimiento
var movimientoSalida = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = 1,
ProveedorID = 1,
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
FechaFactura = DateTime.Now,
FechaRecepcion = DateTime.Now,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar<MovimientoInventario>(movimientoSalida);
if (movimientoSalida.MovimientoInventarioID < 1)
{
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
var detalleMovimientoS = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleMovimientoS);
//No se descuenta por que ya se habia descontado en el traspaso anterior
// Ahora sí se generan dos registros en kardex, uno de entrada y luego uno de salida, para que al final quede igual
// Se hace así para mantener un registro de la operación
// Se hace primero la entrada
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
, sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
// Luego la salida
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.SalidaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
, sOrigen, sDestino, (ContingenciaCompleta.Diferencia.Valor() * -1)
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
#endregion
break;
case 5:
#region [ Traspaso ]
//Almacenar traspaso
var traspaso = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
ImporteTotal = 0,
FueLiquidado = false,
UsuarioSolicitoTraspasoID = Contingencia.UsuarioSolucionoID,
ExisteContingencia = false,
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID)
};
Datos.Guardar<MovimientoInventario>(traspaso);
//Almacenar el detalle del traspaso
if (traspaso.MovimientoInventarioID > 0)
{
var detalleTraspaso = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = traspaso.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate<MovimientoInventarioDetalle>(detalleTraspaso);
//No se descuenta por que ya se habia descontado en el primer traspaso
}
#endregion
break;
default:
break;
}
}
SplashScreen.Close();
this.btnGuardar.Enabled = true;
new Notificacion("Conflicto Resuelto exitosamente", 2 * 1000).Mostrar(Principal.Instance);
catalogosTraspasos.Instance.CustomInvoke<catalogosTraspasos>(m => m.ActualizarListadoConflictos());
}
catch (Exception ex)
{
SplashScreen.Close();
this.btnGuardar.Enabled = true;
Util.MensajeError(ex.Message, GlobalClass.NombreApp);
}
this.Close();
}
protected override void btnGuardar_Click(object sender, EventArgs e)
{
try
{
if (!Validaciones())
{
return;
}
if (EsNuevo)
{
}
else
{
int iAutorizoID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
if (ResU.Exito)
{
iAutorizoID = ResU.Respuesta.UsuarioID;
}
else
{
Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
return;
}
SplashScreen.Show(new Splash());
this.btnGuardar.Enabled = false;
var ContingenciaCompleta = Datos.GetEntity <MovimientoInventarioContingenciasView>(c => c.MovimientoInventarioTraspasoContingenciaID == Contingencia.MovimientoInventarioTraspasoContingenciaID);
if (null == ContingenciaCompleta)
{
return;
}
//Actualiza la contingencia
Contingencia.FechaModificacion = DateTime.Now;
Contingencia.MovimientoInventarioEstatusContingenciaID = 1;
Contingencia.UsuarioID = GlobalClass.UsuarioGlobal.UsuarioID;
Contingencia.UsuarioSolucionoID = GlobalClass.UsuarioGlobal.UsuarioID;
Contingencia.FechaSoluciono = DateTime.Now;
Contingencia.TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue);
Contingencia.TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue);
Contingencia.ObservacionSolucion = this.txtObservacion.Text;
if (Util.Entero(this.cboTipoOperacion.SelectedValue) == Cat.TiposDeOperacionMovimientos.SalidaInventario)
{
Contingencia.ObservacionSolucion += (" - SE CREA UNA ENTRADA PARA DEVOLVER EL TRASPASO A LA TIENDA ORIGEN Y EN EL SEGUNDO MOVIMIENTO UNA SALIDA PARA PODER HACER LA SALIDA DEL INVENTARIO");
}
Contingencia.FechaModificacion = DateTime.Now;
Datos.SaveOrUpdate <MovimientoInventarioTraspasoContingencia>(Contingencia);
int iSucursalID = ContingenciaCompleta.SucursalOrigenID.Valor();
string sOrigen = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalOrigenID.Valor());
string sDestino = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalDestinoID.Valor());
var oPrecio = Datos.GetEntity <PartePrecio>(c => c.ParteID == ContingenciaCompleta.ParteID && c.Estatus);
switch (Util.Entero(cboTipoOperacion.SelectedValue))
{
case 2:
#region [ Entrada Inventario ]
//Insertar Movimiento
var movimientoEntradaI = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = 1,
ProveedorID = 1,
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
FechaFactura = DateTime.Now,
FechaRecepcion = DateTime.Now,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = ContingenciaCompleta.TipoConceptoOperacionID,
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar <MovimientoInventario>(movimientoEntradaI);
if (movimientoEntradaI.MovimientoInventarioID < 1)
{
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
var detalleMovimiento = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimiento);
//Actualizar ParteExistencia
/* var sucursalId = ContingenciaCompleta.SucursalOrigenID;
* var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == ContingenciaCompleta.ParteID && p.SucursalID == sucursalId);
* if (existencia != null)
* {
* existencia.Existencia += Util.ConvertirDecimal(ContingenciaCompleta.Diferencia);
* Datos.Guardar<ParteExistencia>(existencia);//dmod
* }
*/
// AdmonProc.AgregarExistencia(ContingenciaCompleta.ParteID, sucursalId.Valor(), ContingenciaCompleta.Diferencia.Valor()
// , Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
// Se modifica la existencia y el kardex
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Entrada"
, sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
#endregion
break;
case 3:
#region [ Salida Inventario ]
//Insertar Movimiento
var movimientoSalida = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = 1,
ProveedorID = 1,
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
FechaFactura = DateTime.Now,
FechaRecepcion = DateTime.Now,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar <MovimientoInventario>(movimientoSalida);
if (movimientoSalida.MovimientoInventarioID < 1)
{
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
var detalleMovimientoS = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimientoS);
//No se descuenta por que ya se habia descontado en el traspaso anterior
// Ahora sí se generan dos registros en kardex, uno de entrada y luego uno de salida, para que al final quede igual
// Se hace así para mantener un registro de la operación
// Se hace primero la entrada
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
, sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
// Luego la salida
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.SalidaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
, sOrigen, sDestino, (ContingenciaCompleta.Diferencia.Valor() * -1)
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
#endregion
break;
case 5:
#region [ Traspaso ]
//Almacenar traspaso
var traspaso = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
ImporteTotal = 0,
FueLiquidado = false,
UsuarioSolicitoTraspasoID = Contingencia.UsuarioSolucionoID,
ExisteContingencia = false,
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID)
};
Datos.Guardar <MovimientoInventario>(traspaso);
//Almacenar el detalle del traspaso
if (traspaso.MovimientoInventarioID > 0)
{
var detalleTraspaso = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = traspaso.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleTraspaso);
//No se descuenta por que ya se habia descontado en el primer traspaso
}
#endregion
break;
default:
break;
}
}
SplashScreen.Close();
this.btnGuardar.Enabled = true;
new Notificacion("Conflicto Resuelto exitosamente", 2 * 1000).Mostrar(Principal.Instance);
catalogosTraspasos.Instance.CustomInvoke <catalogosTraspasos>(m => m.ActualizarListadoConflictos());
}
catch (Exception ex)
{
SplashScreen.Close();
this.btnGuardar.Enabled = true;
Util.MensajeError(ex.Message, GlobalClass.NombreApp);
}
this.Close();
}
public static MovimientoInventario CrearDevolucionProveedor(int iProveedorID, int iOrigenID, decimal mImporte, string sObservacion)
{
var oMov = new MovimientoInventario()
{
TipoOperacionID = Cat.TiposDeOperacionMovimientos.DevolucionAProveedor,
ProveedorID = iProveedorID,
// DevolucionOrigenID = iOrigenID,
ImporteTotal = mImporte,
Observacion = sObservacion
};
Datos.Guardar<MovimientoInventario>(oMov);
return oMov;
}