public static void AfectarExistenciaYKardex(int iParteID, int iSucursalID, int iOperacionID, string sFolio, int iUsuarioID, string sEntidad
, string sOrigen, string sDestino, decimal mCantidad, decimal mImporte, string sTabla, int iId)
{
// Se manda a afectar la existencia
AdmonProc.AgregarExistencia(iParteID, iSucursalID, mCantidad, sTabla, iId);
// Se manda a afectar en el kardex
var oSucursal = Datos.GetEntity <Sucursal>(c => c.SucursalID == iSucursalID && c.Estatus);
var oKardex = new ParteKardex()
{
ParteID = iParteID,
OperacionID = iOperacionID,
SucursalID = iSucursalID,
Folio = sFolio,
Fecha = DateTime.Now,
RealizoUsuarioID = iUsuarioID,
Entidad = sEntidad,
Origen = sOrigen,
Destino = sDestino,
Cantidad = mCantidad,
Importe = mImporte,
RelacionTabla = sTabla,
RelacionID = iId
};
AdmonProc.RegistrarKardex(oKardex);
}
public static ResAcc Venta(Venta oVenta, List <VentaDetalle> Detalle)
{
bool bMod = (oVenta.VentaID > 0);
if (bMod)
{
throw new Exception("No se ha programado funcionalidad para cuando la Venta ya exista.");
}
// Se generan datos predeterminados o globales, en caso de que apliquen
oVenta.Fecha = (oVenta.Fecha != DateTime.MinValue ? oVenta.Fecha : DateTime.Now);
oVenta.VentaEstatusID = (oVenta.VentaEstatusID > 0 ? oVenta.VentaEstatusID : Cat.VentasEstatus.Realizada);
oVenta.RealizoUsuarioID = (oVenta.RealizoUsuarioID > 0 ? oVenta.RealizoUsuarioID : Theos.UsuarioID);
oVenta.SucursalID = (oVenta.SucursalID > 0 ? oVenta.SucursalID : Theos.SucursalID);
oVenta.ComisionistaClienteID = (oVenta.ComisionistaClienteID > 0 ? oVenta.ComisionistaClienteID : null);
oVenta.ClienteVehiculoID = (oVenta.ClienteVehiculoID > 0 ? oVenta.ClienteVehiculoID : null);
// Se obtiene el folio correspondiente
/* string sFolio = Config.Valor("Ventas.Folio");
* Config.EstablecerValor("Ventas.Folio", (Util.ConvertirEntero(sFolio) + 1).ToString().PadLeft(7, '0'));
* oVenta.Folio = sFolio; */
// Se guarda la venta
Datos.Guardar <Venta>(oVenta);
// Se guarda el detalle
foreach (var ParteDetalle in Detalle)
{
if (ParteDetalle.VentaDetalleID > 0)
{
continue; // No es una venta nueva, no se ha especificado que hacer en estos casos
}
ParteDetalle.VentaID = oVenta.VentaID;
Datos.Guardar <VentaDetalle>(ParteDetalle);
// Se afecta la existencia
// AdmonProc.AgregarExistencia(ParteDetalle.ParteID, oVenta.SucursalID, (ParteDetalle.Cantidad * -1), Cat.Tablas.Venta, oVenta.VentaID);
// Se meten datos a kardex que se actualizarán posteriormente, al cobrar la venta
AdmonProc.AfectarExistenciaYKardex(ParteDetalle.ParteID, oVenta.SucursalID, Cat.OperacionesKardex.Venta, null, oVenta.RealizoUsuarioID, "", "", ""
, (ParteDetalle.Cantidad * -1), 0, Cat.Tablas.Venta, oVenta.VentaID);
}
// Se generar datos relevantes al cliente comisionista, si hubiera
if (oVenta.ComisionistaClienteID.Valor() > 0)
{
// Se calcula el importe de la comisión
decimal mComision = UtilDatos.VentaComisionCliente(oVenta.VentaID, oVenta.ComisionistaClienteID.Valor());
// Se genera una nota de crédito, por la comisión
if (mComision > 0)
{
VentasProc.GenerarNotaDeCredito(oVenta.ComisionistaClienteID.Valor(), mComision, "", Cat.OrigenesNotaDeCredito.Comision, oVenta.VentaID);
}
}
return(new ResAcc(true));
}
public static void EliminarVenta(int iVentaID)
{
var oVenta = Datos.GetEntity <Venta>(q => q.VentaID == iVentaID && q.Estatus);
// De momento sólo están contempladas las ventas que sólo han sido registradas. No cobradas, pagadas, canceladas
if (oVenta.VentaEstatusID != Cat.VentasEstatus.Realizada)
{
return;
}
var oVentaDet = Datos.GetListOf <VentaDetalle>(q => q.VentaID == oVenta.VentaID && q.Estatus);
// Se regresa la existencia y se borra el detalle de la venta
foreach (var oParteDet in oVentaDet)
{
AdmonProc.AgregarExistencia(oParteDet.ParteID, oVenta.SucursalID, oParteDet.Cantidad, Cat.Tablas.Venta, iVentaID);
Datos.Eliminar <VentaDetalle>(oParteDet, true);
}
// Se borra la venta en sí
Datos.Eliminar <Venta>(oVenta, true);
// Se borran los datos del kardex
var oPartesKardex = Datos.GetListOf <ParteKardex>(c => c.OperacionID == Cat.OperacionesKardex.Venta && c.RelacionTabla == Cat.Tablas.Venta &&
c.RelacionID == iVentaID);
foreach (var oReg in oVentaDet)
{
var oKardex = oPartesKardex.FirstOrDefault(c => c.ParteID == oReg.ParteID);
if (oKardex == null)
{
continue;
}
Datos.Eliminar <ParteKardex>(oKardex);
// Se verifica si hubo algún otro movimiento en kardex de la misma parte, para hacer el reajuste
var oDespues = Datos.GetListOf <ParteKardex>(c => c.ParteKardexID > oKardex.ParteKardexID && c.ParteID == oKardex.ParteID);
foreach (var oRegD in oDespues)
{
oRegD.ExistenciaNueva += (oKardex.Cantidad * -1);
Datos.Guardar <ParteKardex>(oRegD);
}
}
}
public static ResAcc RecibirTraspaso(int iUsuarioID, string sMotivo, List <modDetalleTraspaso> oDetalle, bool bValidarContingencia)
{
if (oDetalle.Count <= 0)
{
return(new ResAcc("No hay nada que recibir."));
}
// Validar que lo recibido sea menor o igual que lo enviado
foreach (var oReg in oDetalle)
{
if (oReg.Recibido > oReg.Cantidad)
{
return(new ResAcc("Existen uno o más artículos que tienen una cantidad recibida mayor a lo enviado."));
}
}
// Se verifica si existe alguna contingencia
bool bExisteContingencia = false;
foreach (var oReg in oDetalle)
{
if (oReg.Recibido < oReg.Cantidad)
{
bExisteContingencia = true;
break;
}
}
if (bExisteContingencia && bValidarContingencia)
{
return(new ResAcc("El traspaso tiene uno o más conflictos.", Cat.CodigosRes.ConflictoEnTraspasos));
}
// Se valida el motivo, en caso de que haya habido contingencia
if (bExisteContingencia && string.IsNullOrEmpty(sMotivo))
{
return(new ResAcc("Debes especificar un motivo."));
}
// Se obtiene el MovimientoInventario correspondiente al traspaso
int iRecibirUnoID = oDetalle[0].MovimientoInventarioDetalleID;
var oRecibirUno = Datos.GetEntity <MovimientoInventarioDetalle>(c => c.MovimientoInventarioDetalleID == iRecibirUnoID && c.Estatus);
int iMovID = oRecibirUno.MovimientoInventarioID;
var oTraspasoV = Datos.GetEntity <MovimientoInventarioView>(c => c.MovimientoInventarioID == iMovID);
int iSucursalID = oTraspasoV.SucursalDestinoID.Valor();
//
decimal mCostoTotal = 0;
foreach (var oReg in oDetalle)
{
// Si la cantidad recibida es menor a lo enviado, almacenar la contingencia
if (oReg.Recibido < oReg.Cantidad)
{
var contingencia = new MovimientoInventarioTraspasoContingencia()
{
MovimientoInventarioID = iMovID,
MovimientoInventarioDetalleID = oReg.MovimientoInventarioDetalleID,
ParteID = oReg.ParteID,
CantidadEnviada = oReg.Cantidad,
CantidadRecibida = oReg.Recibido,
CantidadDiferencia = (oReg.Cantidad - oReg.Recibido),
Comentario = sMotivo,
UsuarioID = iUsuarioID,
MovimientoInventarioEstatusContingenciaID = Cat.TraspasoEstatusContingencias.NoSolucionado
};
Datos.Guardar <MovimientoInventarioTraspasoContingencia>(contingencia);
}
//Aumentar la existencia actual de la sucursal destino
var oParte = Datos.GetEntity <Parte>(c => c.ParteID == oReg.ParteID && c.Estatus);
if (!oParte.EsServicio.Valor())
{
var existencia = Datos.GetEntity <ParteExistencia>(p => p.ParteID == oReg.ParteID && p.SucursalID == iSucursalID);
if (existencia != null)
{
var inicial = existencia.Existencia;
existencia.Existencia += oReg.Recibido;
existencia.UsuarioID = iUsuarioID;
existencia.FechaModificacion = DateTime.Now;
Datos.Guardar <ParteExistencia>(existencia);
var historial = new MovimientoInventarioHistorial()
{
MovmientoInventarioID = iMovID,
ParteID = oReg.ParteID,
ExistenciaInicial = Util.Decimal(inicial),
ExistenciaFinal = Util.Decimal(existencia.Existencia),
SucursalID = iSucursalID,
UsuarioID = iUsuarioID
};
Datos.Guardar <MovimientoInventarioHistorial>(historial);
}
}
// Se agrega al Kardex
var oPartePrecio = Datos.GetEntity <PartePrecio>(c => c.ParteID == oReg.ParteID && c.Estatus);
AdmonProc.RegistrarKardex(new ParteKardex()
{
ParteID = oReg.ParteID,
OperacionID = Cat.OperacionesKardex.EntradaTraspaso,
SucursalID = iSucursalID,
Folio = iMovID.ToString(),
Fecha = DateTime.Now,
RealizoUsuarioID = iUsuarioID,
Entidad = Util.Cadena(oTraspasoV.NombreProveedor),
Origen = oTraspasoV.SucursalOrigen,
Destino = oTraspasoV.SucursalDestino,
Cantidad = oReg.Recibido,
Importe = oPartePrecio.Costo.Valor()
});
// Se suma el importe de cada parte, para crear la póliza
mCostoTotal += oPartePrecio.Costo.Valor();
}
// Se genera la póliza especial correspondiente (AfeConta)
var oUsuario = Datos.GetEntity <Usuario>(c => c.UsuarioID == iUsuarioID && c.Estatus);
var oPoliza = ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Diario, string.Format("TRASPASO ORIGEN {0:00} DESTINO {1:00}"
, oTraspasoV.SucursalOrigenID, oTraspasoV.SucursalDestinoID), Cat.ContaCuentasAuxiliares.Inventario, 0, mCostoTotal
, oUsuario.NombreUsuario, Cat.Tablas.MovimientoInventario, iMovID, iSucursalID);
//Actualizar el movimiento con los datos (fecha y usuario que recibio)
var movimiento = Datos.GetEntity <MovimientoInventario>(m => m.MovimientoInventarioID == iMovID);
if (null != movimiento)
{
movimiento.ExisteContingencia = bExisteContingencia;
movimiento.UsuarioRecibioTraspasoID = iUsuarioID;
movimiento.FechaRecepcion = DateTime.Now;
movimiento.FechaModificacion = DateTime.Now;
Datos.Guardar <MovimientoInventario>(movimiento);
}
return(new ResAcc());
}
public static ProveedorParteGanancia ObtenerParteDescuentoGanancia(int?iProveedorID, int?iMarcaID, int?iLineaID, int?iParteID)
{
return(AdmonProc.ObtenerParteDescuentoGanancia(iProveedorID, iMarcaID, iLineaID, iParteID, false));
}
public static string ObtenerImagenParte(int iParteID)
{
var oImagenes = AdmonProc.ObtenerImagenesParte(iParteID);
return(oImagenes.Count > 0 ? oImagenes[0] : "");
}
public static ResAcc VentaDevolucion(VentaDevolucion oDevolucion, List <VentaDevolucionDetalle> oDetalle)
{
// Se generan datos predeterminados o globales, en caso de que apliquen
oDevolucion.Fecha = (oDevolucion.Fecha != DateTime.MinValue ? oDevolucion.Fecha : DateTime.Now);
oDevolucion.SucursalID = (oDevolucion.SucursalID > 0 ? oDevolucion.SucursalID : Theos.SucursalID);
// Se guarda la devolución
Datos.Guardar <VentaDevolucion>(oDevolucion);
// Se guarda el detalle
VentaDetalle oParteVenta;
foreach (var ParteDetalle in oDetalle)
{
ParteDetalle.VentaDevolucionID = oDevolucion.VentaDevolucionID;
Datos.Guardar <VentaDevolucionDetalle>(ParteDetalle);
// Se quita el producto de la venta
oParteVenta = Datos.GetEntity <VentaDetalle>(q => q.Estatus &&
q.VentaID == oDevolucion.VentaID &&
q.ParteID == ParteDetalle.ParteID &&
q.Cantidad == ParteDetalle.Cantidad &&
q.PrecioUnitario == ParteDetalle.PrecioUnitario &&
q.Iva == ParteDetalle.Iva);
oParteVenta.Estatus = false;
Datos.Guardar <VentaDetalle>(oParteVenta, false);
// Se afecta la existencia
// AdmonProc.AgregarExistencia(ParteDetalle.ParteID, GlobalClass.SucursalID, ParteDetalle.Cantidad, Cat.Tablas.VentaDevolucion, oDevolucion.VentaDevolucionID);
var oDevV = Datos.GetEntity <VentasDevolucionesView>(c => c.VentaDevolucionID == oDevolucion.VentaDevolucionID);
AdmonProc.AfectarExistenciaYKardex(ParteDetalle.ParteID, Theos.SucursalID, Cat.OperacionesKardex.VentaCancelada, oDevV.FolioDeVenta
, oDevV.RealizoUsuarioID, oDevV.Cliente, oDevV.ClienteID.ToString(), oDevV.Sucursal, ParteDetalle.Cantidad
, (ParteDetalle.PrecioUnitario + ParteDetalle.Iva), Cat.Tablas.VentaDevolucion, oDevolucion.VentaDevolucionID);
}
// Si es cancelación, se cambia el estatus de la venta
var oVenta = Datos.GetEntity <Venta>(c => c.VentaID == oDevolucion.VentaID && c.Estatus);
if (oDevolucion.EsCancelacion)
{
// Se verifica si la venta ha tenido pagos
var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == oDevolucion.VentaID);
oVenta.VentaEstatusID = (oVentaV.Pagado > 0 ? Cat.VentasEstatus.Cancelada : Cat.VentasEstatus.CanceladaSinPago);
Datos.Guardar <Venta>(oVenta);
}
// Se verifican notas de crédito que pudieran cancelarse, por cliente comisionista
if (oVenta.ComisionistaClienteID > 0)
{
// Se calcula el importe de la comisión que se debe quitar
var oComisionista = Datos.GetEntity <Cliente>(q => q.ClienteID == oVenta.ComisionistaClienteID && q.Estatus);
decimal mComision = 0;
PreciosParte oPrecios;
foreach (var ParteD in oDetalle)
{
oPrecios = new PreciosParte(ParteD.ParteID);
mComision += (((ParteD.PrecioUnitario + ParteD.Iva) - oPrecios.ObtenerPrecio(oComisionista.ListaDePrecios)) * ParteD.Cantidad);
}
// Se genera una nota de crédito negativa
if (mComision > 0)
{
VentasProc.GenerarNotaDeCredito(oComisionista.ClienteID, (mComision * -1), "", Cat.OrigenesNotaDeCredito.Devolucion, oVenta.VentaID);
}
}
return(new ResAcc(true));
}
