public static void Completar9500(Cotizacion9500 o9500, decimal mSobrante, bool bDevolverEfectivo)
{
// Se cancela la venta del anticipo
var oVentaAnt = Datos.GetEntity <Venta>(q => q.VentaID == o9500.AnticipoVentaID && q.VentaEstatusID != Cat.VentasEstatus.Cancelada &&
q.VentaEstatusID != Cat.VentasEstatus.CanceladaSinPago && q.Estatus);
if (oVentaAnt != null)
{
oVentaAnt.VentaEstatusID = Cat.VentasEstatus.Cancelada;
Datos.Guardar <Venta>(oVentaAnt);
// Se genera una devolución de efectivo (si se realizó un pago) de la venta cancelada, pues se generará una nueva venta con el importe total
if (Datos.Exists <VentaPago>(q => q.VentaID == o9500.AnticipoVentaID && q.Estatus))
{
VentasProc.GenerarDevolucionDeEfectivo(o9500.AnticipoVentaID.Valor(), o9500.Anticipo - (mSobrante > 0 ? mSobrante : 0));
}
}
// Si hubo un sobrante, se genera nota de crédito o se devuelve efectivo
if (mSobrante > 0)
{
if (bDevolverEfectivo)
{
VentasProc.GenerarDevolucionDeEfectivo(oVentaAnt.VentaID, mSobrante);
}
else
{
VentasProc.GenerarNotaDeCredito(o9500.ClienteID, mSobrante, "", Cat.OrigenesNotaDeCredito.Anticipo9500, oVentaAnt.VentaID);
}
}
// Se modifica el Estatus del 9500
o9500.EstatusGenericoID = Cat.EstatusGenericos.Completada;
Datos.Guardar <Cotizacion9500>(o9500);
}
public static ResAcc VentaGarantia(VentaGarantia oGarantia)
{
// Se generan datos predeterminados o globales, en caso de que apliquen
oGarantia.Fecha = (oGarantia.Fecha != DateTime.MinValue ? oGarantia.Fecha : DateTime.Now);
oGarantia.SucursalID = (oGarantia.SucursalID > 0 ? oGarantia.SucursalID : Theos.SucursalID);
// Se guarda la devolución
Datos.Guardar <VentaGarantia>(oGarantia);
// Se afectan los datos en el detalle de la venta
// Se quita el producto de la venta, si aplica
if (oGarantia.AccionID != Cat.VentasGarantiasAcciones.RevisionDeProveedor)
{
var oParteVenta = Datos.GetEntity <VentaDetalle>(q => q.Estatus &&
q.VentaID == oGarantia.VentaID &&
q.ParteID == oGarantia.ParteID &&
q.PrecioUnitario == oGarantia.PrecioUnitario &&
q.Iva == oGarantia.Iva);
if (oParteVenta.Cantidad > 1)
{
oParteVenta.Cantidad--;
Datos.Guardar <VentaDetalle>(oParteVenta);
}
else
{
Datos.Eliminar <VentaDetalle>(oParteVenta, true);
}
}
return(new ResAcc(true));
}
public static string LeyendaDeVehiculo(int iClienteVehiculoID)
{
var oVehiculo = Datos.GetEntity <ClientesFlotillasView>(c => c.ClienteFlotillaID == iClienteVehiculoID);
return(string.Format("NO.ECO. {0}, {1}, {2} MOD. {3}, {4}, {5}, PLACAS {6} KM {7}",
oVehiculo.NumeroEconomico, oVehiculo.Marca, oVehiculo.Modelo, oVehiculo.Anio, oVehiculo.Motor, oVehiculo.Tipo, oVehiculo.Placa, oVehiculo.Kilometraje));
}
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 ValidarPermiso(int iUsuarioID, string sPermiso)
{
var oUsuarioPerV = Datos.GetEntity <UsuariosPermisosView>(c => c.UsuarioID == iUsuarioID && c.Permiso == sPermiso);
bool bValido = Datos.Exists <UsuariosPermisosView>(c => c.UsuarioID == iUsuarioID && c.Permiso == sPermiso);
if (bValido)
{
return(new ResAcc(true));
}
else
{
var oRes = new ResAcc(false);
var oPermiso = Datos.GetEntity <Permiso>(c => c.NombrePermiso == sPermiso && c.Estatus);
if (oPermiso == null)
{
oRes.Mensaje = "El Permiso especificado ni siquiera existe. ¡Échame la mano!";
}
else
{
oRes.Mensaje = oPermiso.MensajeDeError;
}
return(oRes);
}
}
public static ResAcc ParteComplementaria(int iParteID, int iParteIDComplementaria)
{
// Se verifica si son las partes son iguales, en cuyo caso no se hace nada
if (iParteIDComplementaria == iParteID)
{
return(new ResAcc(false));
}
// Se verifica si ya existe la relación de complementarios
var oComp = Datos.GetEntity <ParteComplementaria>(c => c.ParteID == iParteID && c.ParteIDComplementaria == iParteIDComplementaria);
if (oComp != null)
{
return(new ResAcc(true));
}
// Se agrega el registro de la parte complementaria
oComp = new ParteComplementaria()
{
ParteID = iParteID,
ParteIDComplementaria = iParteIDComplementaria,
RealizoUsuarioID = Theos.UsuarioID
};
Datos.Guardar <ParteComplementaria>(oComp);
return(new ResAcc(true));
}
public static Usuario ObtenerUsuarioDeContrasenia(string sContrasenia)
{
string sContraseniaEnc = UtilTheos.Encriptar(sContrasenia);
var oUsuario = Datos.GetEntity <Usuario>(q => q.Contrasenia == sContraseniaEnc && q.Estatus);
return(oUsuario);
}
public static string GenerarSugerenciaNombreParte(int iLineaID, int iMarcaID, string sNumeroDeParte)
{
var oLinea = Datos.GetEntity <Linea>(c => c.LineaID == iLineaID && c.Estatus);
var oMarca = Datos.GetEntity <MarcaParte>(c => c.MarcaParteID == iMarcaID && c.Estatus);
return(string.Format("{0} {1} {2}", oLinea.Abreviacion, oMarca.Abreviacion, sNumeroDeParte).Trim());
}
public static bool VerGuardar9500(int iParteID)
{
var oParte = Datos.GetEntity <Parte>(c => c.ParteID == iParteID && c.Estatus);
oParte.Es9500 = !Datos.Exists <ParteMaxMin>(c => c.ParteID == iParteID && c.Maximo > 0);
Datos.Guardar <Parte>(oParte);
return(oParte.Es9500.Valor());
}
public static bool VerCierreDeDaja()
{
//DateTime dHoy = DateTime.Today.AddDays(-3);
DateTime dHoy = DateTime.Today;
var oDia = Datos.GetEntity <CajaEfectivoPorDia>(q => q.SucursalID == Theos.SucursalID && q.Dia == dHoy && q.Estatus);
return(oDia != null && oDia.Cierre != null);
}
public static ResAcc Parte(Parte oParte, PartePrecio oPartePrecio)
{
// Se llenan datos predeterminados, si no han sido llenados
oParte.ParteEstatusID = (oParte.ParteEstatusID > 0 ? oParte.ParteEstatusID : Cat.PartesEstatus.Activo);
oParte.MedidaID = (oParte.MedidaID > 0 ? oParte.MedidaID : Cat.Medidas.Pieza);
oParte.UnidadEmpaque = (oParte.UnidadEmpaque > 0 ? oParte.UnidadEmpaque : 1);
oParte.AplicaComision = (oParte.AplicaComision.HasValue ? oParte.AplicaComision : true);
oParte.Etiqueta = (oParte.Etiqueta.HasValue ? oParte.Etiqueta : true);
// Se guarda el registro de la parte
Datos.Guardar <Parte>(oParte);
// Se guarda el registro del precio
if (oPartePrecio != null)
{
oPartePrecio.ParteID = oParte.ParteID;
oPartePrecio.CostoConDescuento = (oPartePrecio.CostoConDescuento.HasValue ? oPartePrecio.CostoConDescuento : oPartePrecio.Costo);
Datos.Guardar <PartePrecio>(oPartePrecio);
}
// Se generan los registros de existencia, uno por cada sucursal
var oSucursales = Datos.GetListOf <Sucursal>(q => q.Estatus);
foreach (var oSucursal in oSucursales)
{
Datos.Guardar <ParteExistencia>(new ParteExistencia()
{
ParteID = oParte.ParteID,
SucursalID = oSucursal.SucursalID,
Existencia = 0
});
}
// Se generan los registros para Máximos y Mínimos, uno por cada sucursal
foreach (var oSucursal in oSucursales)
{
// Se buscan los criterios generales predefinidos, para asignarlos
var oCriterioPred = Datos.GetEntity <ParteMaxMinCriterioPredefinido>(q => q.SucursalID == oSucursal.SucursalID &&
q.ProveedorID == oParte.ProveedorID && q.MarcaID == oParte.MarcaParteID && q.LineaID == oParte.LineaID);
//
Datos.Guardar <ParteMaxMin>(new ParteMaxMin()
{
ParteID = oParte.ParteID,
SucursalID = oSucursal.SucursalID,
Calcular = (oCriterioPred == null ? null : oCriterioPred.Calcular),
VentasGlobales = (oCriterioPred == null ? null : oCriterioPred.VentasGlobales)
});
}
// Se genera el registro de Abc (ParteAbc)
Datos.Guardar <ParteAbc>(new ParteAbc()
{
ParteID = oParte.ParteID,
AbcDeVentas = "Z"
});
return(new ResAcc(true));
}
public static void BorrarTemporal(string sProceso, int iId)
{
var oTemp = Datos.GetEntity <Temporal>(c => c.Proceso == sProceso && c.Identificador == iId);
if (oTemp != null)
{
Datos.Eliminar <Temporal>(oTemp);
}
}
public static void Cancelar9500(int i9500ID, string sMotivo, int iUsuarioID)
{
var o9500 = Datos.GetEntity <Cotizacion9500>(q => q.Cotizacion9500ID == i9500ID && q.Estatus);
var o9500Detalle = Datos.GetListOf <Cotizacion9500Detalle>(q => q.Cotizacion9500ID == i9500ID && q.Estatus);
// Se verifica si se cobró el anticipo, para cancelarlo
if (o9500.Anticipo > 0)
{
var oAnticipo = Datos.GetEntity <Venta>(c => c.VentaID == o9500.AnticipoVentaID && c.Estatus);
if (oAnticipo.VentaEstatusID == Cat.VentasEstatus.Cobrada || oAnticipo.VentaEstatusID == Cat.VentasEstatus.Completada)
{
// Si se pagó, se genera una devolución
var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == o9500.AnticipoVentaID);
if (oVentaV.Pagado > 0)
{
VentasProc.GenerarDevolucionDeEfectivo(oVentaV.VentaID, oVentaV.Pagado);
}
// Se cancela la venta del anticipo
oAnticipo.VentaEstatusID = (oVentaV.Pagado > 0 ? Cat.VentasEstatus.Cancelada : Cat.VentasEstatus.CanceladaSinPago);
Datos.Guardar <Venta>(oAnticipo);
}
}
// Se borran las partes del 9500, si no han sido usadas
foreach (var oParte in o9500Detalle)
{
// Se valida que la parte no haya sido usada en ventas
if (Datos.Exists <VentaDetalle>(q => q.ParteID == oParte.ParteID))
{
continue;
}
// Se valida que la parte no haya sido usada en almacén
if (Datos.Exists <MovimientoInventarioDetalle>(q => q.ParteID == oParte.ParteID))
{
continue;
}
// Se borra -> Deshabilitado hasta tener las validaciones del Almacén
Guardar.EliminarParte(oParte.ParteID);
}
// Se verifica si hay autorizaciones, para borrarlas
var oAuts = Datos.GetListOf <Autorizacion>(c => (c.AutorizacionProcesoID == Cat.AutorizacionesProcesos.c9500PrecioFueraDeRango ||
c.AutorizacionProcesoID == Cat.AutorizacionesProcesos.c9500SinAnticipo) && c.Tabla == Cat.Tablas.Tabla9500 && c.TablaRegistroID == i9500ID && c.Estatus);
foreach (var oReg in oAuts)
{
oReg.Estatus = true;
Datos.Guardar <Autorizacion>(oReg);
}
// Se cancela el 9500
o9500.EstatusGenericoID = Cat.EstatusGenericos.CanceladoAntesDeVender;
o9500.BajaUsuarioID = iUsuarioID;
o9500.BajaMotivo = sMotivo;
Datos.Guardar <Cotizacion9500>(o9500);
}
public static ResAcc <bool> CancelarNotaDeCredito(int iNotaDeCreditoID, string sMotivoDeBaja)
{
var oVale = Datos.GetEntity <NotaDeCredito>(c => c.NotaDeCreditoID == iNotaDeCreditoID && c.Estatus);
oVale.Valida = false;
oVale.MotivoBaja = sMotivoDeBaja;
Datos.Guardar <NotaDeCredito>(oVale);
return(new ResAcc <bool>(true));
}
public static ResAcc ParteEquivalencia(int iParteID, int iParteIDEquivalente)
{
// Se obtiene el grupo de cualquiera de las partes
var oParteEq1 = Datos.GetEntity <ParteEquivalente>(c => c.ParteID == iParteID);
var oParteEq2 = Datos.GetEntity <ParteEquivalente>(c => c.ParteID == iParteIDEquivalente);
// Si ninguna de las partes tiene grupo, se crea uno nuevo
int iGrupoID = 0;
if (oParteEq1 == null && oParteEq2 == null)
{
var oEquivalentes = Datos.GetListOf <ParteEquivalente>();
iGrupoID = (oEquivalentes.Count > 0 ? oEquivalentes.Max(c => c.GrupoID) : 0);
iGrupoID++;
}
else
{
iGrupoID = (oParteEq1 == null ? oParteEq2.GrupoID : oParteEq1.GrupoID);
}
// Se agrega la equivalencia de la parte 1, por si no existiera
if (oParteEq1 == null)
{
oParteEq1 = new ParteEquivalente()
{
GrupoID = iGrupoID, ParteID = iParteID
};
oParteEq1.RealizoUsuarioID = Theos.UsuarioID;
Datos.Guardar <ParteEquivalente>(oParteEq1);
}
// Se agrega la equivalencia de la parte 2, según aplique
if (oParteEq2 == null)
{
oParteEq2 = new ParteEquivalente()
{
GrupoID = iGrupoID, ParteID = iParteIDEquivalente
};
oParteEq2.RealizoUsuarioID = Theos.UsuarioID;
Datos.Guardar <ParteEquivalente>(oParteEq2);
}
// Se verifica si las dos ya tenían grupo, pero diferente, en cuyo caso todos se van a un mismo grupo
if (oParteEq1.GrupoID != oParteEq2.GrupoID)
{
var oPartesEq2 = Datos.GetListOf <ParteEquivalente>(c => c.GrupoID == oParteEq2.GrupoID);
foreach (var oEq in oPartesEq2)
{
oEq.GrupoID = oParteEq1.GrupoID;
oEq.RealizoUsuarioID = Theos.UsuarioID;
Datos.Guardar <ParteEquivalente>(oEq);
}
}
return(new ResAcc(true));
}
public static void VerMarcarDisponibilidadNotaDeCreditoProveedor(int iNotaDeCreditoID)
{
var oNotaView = Datos.GetEntity <ProveedoresNotasDeCreditoView>(c => c.ProveedorNotaDeCreditoID == iNotaDeCreditoID);
bool bDisponible = (oNotaView.Restante > 0);
if (oNotaView.Disponible != bDisponible)
{
var oNota = Datos.GetEntity <ProveedorNotaDeCredito>(c => c.ProveedorNotaDeCreditoID == iNotaDeCreditoID);
oNota.Disponible = bDisponible;
Datos.Guardar <ProveedorNotaDeCredito>(oNota);
}
}
public static void VerMarcarDisponibilidadGastoDeCajaParaProveedor(int iCajaEgresoID)
{
var oGastoView = Datos.GetEntity <CajaEgresosProveedoresView>(c => c.CajaEgresoID == iCajaEgresoID);
bool bDisponible = (oGastoView.Restante > 0);
if (oGastoView.AfectadoEnProveedores.Valor() == bDisponible)
{
var oGasto = Datos.GetEntity <CajaEgreso>(c => c.CajaEgresoID == iCajaEgresoID && c.Estatus);
oGasto.AfectadoEnProveedores = !bDisponible;
Datos.Guardar <CajaEgreso>(oGasto);
}
}
public PreciosParte(int iParteID)
{
var oPrecios = Datos.GetEntity <PartePrecio>(q => q.ParteID == iParteID && q.Estatus);
this.ParteID = oPrecios.ParteID;
this.Precios = new decimal[] {
oPrecios.PrecioUno.Valor(),
oPrecios.PrecioDos.Valor(),
oPrecios.PrecioTres.Valor(),
oPrecios.PrecioCuatro.Valor(),
oPrecios.PrecioCinco.Valor()
};
}
public static bool EsFacturaMultiple(int iVentaID)
{
var oVentaFaDe = Datos.GetEntity <VentaFacturaDetalle>(c => c.VentaID == iVentaID && c.Estatus);
if (oVentaFaDe == null)
{
return(false);
}
else
{
return(Datos.Exists <VentasFacturasView>(c => c.VentaFacturaID == oVentaFaDe.VentaFacturaID && c.Ventas > 1));
}
}
public static bool EstablecerValor(int iSucursalID, string sParametro, string sValor)
{
var oConfig = Datos.GetEntity <Configuracion>(q => q.Nombre == sParametro && q.SucursalID == iSucursalID);
if (oConfig == null)
{
return(false);
}
else
{
oConfig.Valor = sValor;
Datos.Guardar <Configuracion>(oConfig);
return(true);
}
}
public static ResAcc ParteVehiculo(ParteVehiculo Objeto)
{
bool bEsMod = (Objeto.ParteVehiculoID > 0);
if (!bEsMod)
{
// Se verifica que no exista ya un registro así
var Existe = Datos.GetEntity <ParteVehiculo>(q => q.ParteID == Objeto.ParteID && q.MotorID == Objeto.MotorID && q.Anio == Objeto.Anio);
if (Existe != null)
{
return(new ResAcc(false, "Ya existe un registro con esas características."));
}
}
return(Datos.Guardar <ParteVehiculo>(Objeto));
}
public static List <string> InventarioUsuariosConteoPendiente()
{
var oLista = new List <string>();
DateTime dHoy = DateTime.Now.Date;
var oConteos = Datos.GetListOf <InventarioConteo>(c => c.Dia == dHoy && !c.Diferencia.HasValue)
.Select(c => new { UsuarioID = c.ConteoUsuarioID }).Distinct();
var oUsuariosSuc = Datos.GetListOf <InventarioUsuario>(c => c.SucursalID == Theos.SucursalID);
foreach (var oReg in oConteos)
{
if (oUsuariosSuc.Any(c => c.InvUsuarioID == oReg.UsuarioID))
{
var oUsuario = Datos.GetEntity <Usuario>(c => c.UsuarioID == oReg.UsuarioID);
oLista.Add(oUsuario.NombreUsuario);
}
}
return(oLista);
}
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 <bool> ValidarUsuarioPermisos(int iUsuarioID, List <string> oPermisos, bool bCumplirTodos)
{
var oUsuarioPer = Datos.GetListOf <UsuariosPermisosView>(c => c.UsuarioID == iUsuarioID);
bool bCumplido;
List <string> oNoCumplidos = new List <string>();
foreach (string sPermiso in oPermisos)
{
bCumplido = false;
// Se busca el permiso en la lista de permisos del usuario
foreach (var oPermiso in oUsuarioPer)
{
if (oPermiso.Permiso == sPermiso)
{
bCumplido = true;
break;
}
}
// Se verifica si el permiso actual se cumplió o no
if (!bCumplido)
{
oNoCumplidos.Add(sPermiso);
}
}
// Se verifica si se cumplió la validación o no
if (bCumplirTodos && oNoCumplidos.Count == 0)
{
return(new ResAcc <bool>(true));
}
else if (!bCumplirTodos && oNoCumplidos.Count < oPermisos.Count)
{
return(new ResAcc <bool>(true));
}
else
{
// Se obtiene el mensaje de error del primer permiso no cumplido
string sPermiso = oNoCumplidos[0];
var oPermiso = Datos.GetEntity <Permiso>(c => c.NombrePermiso == sPermiso && c.Estatus);
return(new ResAcc <bool>(false, oPermiso.MensajeDeError));
}
}
public static string GenerarFormaDePago(List <VentaPagoDetalle> oPagoDetalle)
{
List <VentasPagosDetalleView> oPagoD = null;
oPagoD = new List <VentasPagosDetalleView>();
TipoFormaPago oFormaDePago;
foreach (var oForma in oPagoDetalle)
{
oFormaDePago = Datos.GetEntity <TipoFormaPago>(q => q.TipoFormaPagoID == oForma.TipoFormaPagoID && q.Estatus);
oPagoD.Add(new VentasPagosDetalleView()
{
FormaDePagoID = oForma.TipoFormaPagoID,
FormaDePago = oFormaDePago.NombreTipoFormaPago,
Cuenta = oForma.Cuenta
});
}
return(VentasProc.GenerarFormaDePago(oPagoD));
}
public static List <NotaDeCredito> ObtenerValesCreados(List <VentaPagoDetalle> oPagoDetalle)
{
var oVales = new List <NotaDeCredito>();
foreach (var oReg in oPagoDetalle)
{
if (oReg.TipoFormaPagoID == Cat.FormasDePago.Vale)
{
var oNota = Datos.GetEntity <NotaDeCredito>(c => c.NotaDeCreditoID == oReg.NotaDeCreditoID && c.Estatus);
int iOrigenValeID = (oNota.OrigenID == Cat.OrigenesNotaDeCredito.ImporteRestante ? oNota.RelacionID.Valor() : oNota.NotaDeCreditoID);
var oValeN = Datos.GetEntity <NotaDeCredito>(c => c.OrigenID == Cat.OrigenesNotaDeCredito.ImporteRestante &&
c.RelacionID == iOrigenValeID && c.Valida && c.FechaDeEmision >= oReg.FechaRegistro && c.Estatus);
if (oValeN != null)
{
oVales.Add(oValeN);
}
}
}
return(oVales);
}
public static decimal VentaComisionCliente(int iVentaID, int iComisionistaID)
{
// Se calcula el importe de la comisión
var oVentaDetalle = Datos.GetListOf <VentaDetalle>(q => q.VentaID == iVentaID && q.Estatus);
var oComisionista = Datos.GetEntity <Cliente>(q => q.ClienteID == iComisionistaID && q.Estatus);
if (oComisionista == null)
{
return(0);
}
decimal mComision = 0;
PreciosParte oPrecios;
foreach (var ParteD in oVentaDetalle)
{
oPrecios = new PreciosParte(ParteD.ParteID);
mComision += (((ParteD.PrecioUnitario + ParteD.Iva) - oPrecios.ObtenerPrecio(oComisionista.ListaDePrecios)) * ParteD.Cantidad);
}
return(mComision);
}
public static void AgregarExistencia(int iParteID, int iSucursalID, decimal mAgregar, string sTabla, int iId)
{
// var oParte = General.GetEntity<Parte>(q => q.ParteID == iParteID && q.Estatus);
// if (!oParte.EsServicio.Valor())
if (Datos.Exists <Parte>(c => c.ParteID == iParteID && (!c.EsServicio.HasValue || !c.EsServicio.Value) && c.Estatus))
{
var oParteEx = Datos.GetEntity <ParteExistencia>(q => q.SucursalID == iSucursalID && q.ParteID == iParteID && q.Estatus);
oParteEx.Existencia += mAgregar;
Datos.Guardar <ParteExistencia>(oParteEx);
// Se registra el histórico de la existencia
var oExHis = new ParteExistenciaHistorico()
{
ParteID = iParteID,
Cantidad = mAgregar,
ExistenciaNueva = oParteEx.Existencia.Valor(),
RelacionTabla = sTabla,
RelacionID = iId
};
Datos.Guardar <ParteExistenciaHistorico>(oExHis);
}
}
public static ProveedorParteGanancia ObtenerParteDescuentoGanancia(int?iProveedorID, int?iMarcaID, int?iLineaID, int?iParteID, bool bCompletarConParte)
{
if (bCompletarConParte)
{
var oParte = Datos.GetEntity <Parte>(c => c.ParteID == iParteID && c.Estatus);
if (!iProveedorID.HasValue)
{
iProveedorID = oParte.ProveedorID;
}
if (!iMarcaID.HasValue)
{
iMarcaID = oParte.MarcaParteID;
}
if (!iLineaID.HasValue)
{
iLineaID = oParte.LineaID;
}
}
var oParteGan = Datos.GetEntity <ProveedorParteGanancia>(c => c.ProveedorID == iProveedorID && c.MarcaParteID == iMarcaID &&
c.LineaID == iLineaID && c.ParteID == iParteID);
if (oParteGan == null)
{
oParteGan = Datos.GetEntity <ProveedorParteGanancia>(c => c.ProveedorID == iProveedorID && c.MarcaParteID == iMarcaID &&
c.LineaID == iLineaID);
if (oParteGan == null)
{
oParteGan = Datos.GetEntity <ProveedorParteGanancia>(c => c.ProveedorID == iProveedorID && c.MarcaParteID == iMarcaID);
if (oParteGan == null)
{
oParteGan = Datos.GetEntity <ProveedorParteGanancia>(c => c.ProveedorID == iProveedorID);
}
}
}
return(oParteGan);
}
public static ResAcc EliminarParte(int iParteID)
{
// Se borran los registros MaxMin
var oMaxMins = Datos.GetListOf <ParteMaxMin>(q => q.ParteID == iParteID);
foreach (var oParteMM in oMaxMins)
{
Datos.Eliminar <ParteMaxMin>(oParteMM, false);
}
// Se borran los registros de existencias
var oExistencias = Datos.GetListOf <ParteExistencia>(q => q.ParteID == iParteID && q.Estatus);
foreach (var oParteEx in oExistencias)
{
Datos.Eliminar <ParteExistencia>(oParteEx, true);
}
// Se borran los datos del precio
var oPartePrecio = Datos.GetEntity <PartePrecio>(q => q.ParteID == iParteID && q.Estatus);
if (oPartePrecio != null)
{
Datos.Eliminar <PartePrecio>(oPartePrecio, true);
}
// Se borra el registro de la parte
var oParte = Datos.GetEntity <Parte>(q => q.ParteID == iParteID && q.Estatus);
if (oParte != null)
{
Datos.Eliminar <Parte>(oParte, true);
}
return(new ResAcc(true));
}
