public static void CopiarAplicacionesDeEquivalentes(int iParteID)
{
var oPartesEq = Datos.GetListOf <PartesEquivalentesView>(c => c.ParteID == iParteID);
var oAplicaciones = Datos.GetListOf <ParteVehiculo>(c => c.ParteID == iParteID);
foreach (var oParteEq in oPartesEq)
{
var oAplisEq = Datos.GetListOf <ParteVehiculo>(c => c.ParteID == oParteEq.ParteIDEquivalente);
foreach (var oAplicacion in oAplicaciones)
{
if (oAplisEq.Any(c => c.ModeloID == oAplicacion.ModeloID &&
((!c.Anio.HasValue && !oAplicacion.Anio.HasValue) || c.Anio == oAplicacion.Anio) &&
((!c.MotorID.HasValue && !oAplicacion.MotorID.HasValue) || c.MotorID == oAplicacion.MotorID)))
{
continue;
}
var oAplicacionNueva = new ParteVehiculo()
{
ParteID = oParteEq.ParteIDEquivalente,
ModeloID = oAplicacion.ModeloID,
MotorID = oAplicacion.MotorID,
Anio = oAplicacion.Anio,
TipoFuenteID = oAplicacion.TipoFuenteID,
RegistroUsuarioID = Theos.UsuarioID,
};
Datos.Guardar <ParteVehiculo>(oAplicacionNueva);
}
}
}
public static void RegistrarKardex(ParteKardex oParteKardex)
{
oParteKardex.Folio = (oParteKardex.Folio == null ? "" : oParteKardex.Folio);
// Se verifica si la parte es servicio, para no afectar la existencia nueva
if (Datos.Exists <Parte>(c => c.ParteID == oParteKardex.ParteID && c.EsServicio.Value && c.Estatus))
{
oParteKardex.Cantidad = 0;
}
// Se calcula la existencia nueva
var oParteKardexAnt = Datos.GetListOf <ParteKardex>(c => c.ParteID == oParteKardex.ParteID && c.SucursalID == oParteKardex.SucursalID)
.OrderByDescending(c => c.ParteKardexID).FirstOrDefault();
decimal mExistencia = (oParteKardexAnt == null ? 0 : oParteKardexAnt.ExistenciaNueva);
decimal mCantidad = oParteKardex.Cantidad;
if (oParteKardex.OperacionID == Cat.OperacionesKardex.Venta || oParteKardex.OperacionID == Cat.OperacionesKardex.DevolucionAProveedor ||
oParteKardex.OperacionID == Cat.OperacionesKardex.SalidaInventario || oParteKardex.OperacionID == Cat.OperacionesKardex.SalidaTraspaso)
{
mCantidad *= -1;
}
oParteKardex.ExistenciaNueva = (mExistencia + mCantidad);
Datos.Guardar <ParteKardex>(oParteKardex);
}
public static void CopiarCodigosAlternosDeEquivalentes(int iParteID)
{
var oPartesEq = Datos.GetListOf <PartesEquivalentesView>(c => c.ParteID == iParteID);
var oCodigosAlt = Datos.GetListOf <ParteCodigoAlterno>(c => c.ParteID == iParteID);
foreach (var oParteEq in oPartesEq)
{
foreach (var oCodigoAlt in oCodigosAlt)
{
if (Datos.Exists <ParteCodigoAlterno>(c => c.ParteID == oParteEq.ParteIDEquivalente && c.MarcaParteID == oCodigoAlt.MarcaParteID &&
c.CodigoAlterno == oCodigoAlt.CodigoAlterno))
{
continue;
}
var oCodigoAltNuevo = new ParteCodigoAlterno()
{
ParteID = oParteEq.ParteIDEquivalente,
MarcaParteID = oCodigoAlt.MarcaParteID,
CodigoAlterno = oCodigoAlt.CodigoAlterno,
RealizoUsuarioID = Theos.UsuarioID
};
Datos.Guardar <ParteCodigoAlterno>(oCodigoAltNuevo);
}
}
}
public static List <VentasPagosDetalleView> DeVentaPagoDetalleAVentasPagosDetalleView(List <VentaPagoDetalle> oPagoDetalle)
{
var oRes = new List <VentasPagosDetalleView>();
// Se hace un dictionario con las descripciones de las formas de pago
var oFormasDePago = Datos.GetListOf <TipoFormaPago>(c => c.Estatus);
var oFormasDesc = new Dictionary <int, string>();
foreach (var oReg in oFormasDePago)
{
oFormasDesc.Add(oReg.TipoFormaPagoID, oReg.NombreTipoFormaPago);
}
foreach (var oReg in oPagoDetalle)
{
oRes.Add(new VentasPagosDetalleView()
{
FormaDePagoID = oReg.TipoFormaPagoID,
FormaDePago = oFormasDesc[oReg.TipoFormaPagoID],
Importe = oReg.Importe,
BancoID = oReg.BancoID,
Folio = oReg.Folio,
Cuenta = oReg.Cuenta
});
}
return(oRes);
}
public static void RegistrarKardex(ParteKardex oParteKardex)
{
oParteKardex.Folio = (oParteKardex.Folio == null ? "" : oParteKardex.Folio);
// Se verifica si la parte es servicio, para no afectar la existencia nueva
if (Datos.Exists <Parte>(c => c.ParteID == oParteKardex.ParteID && c.EsServicio.Value && c.Estatus))
{
oParteKardex.Cantidad = 0;
}
// Se calcula la existencia nueva
var oParteKardexAnt = Datos.GetListOf <ParteKardex>(c => c.ParteID == oParteKardex.ParteID && c.SucursalID == oParteKardex.SucursalID)
.OrderByDescending(c => c.ParteKardexID).FirstOrDefault();
decimal mExistencia = (oParteKardexAnt == null ? 0 : oParteKardexAnt.ExistenciaNueva);
decimal mCantidad = oParteKardex.Cantidad;
/* if (oParteKardex.OperacionID == Cat.OperacionesKardex.Venta || oParteKardex.OperacionID == Cat.OperacionesKardex.DevolucionAProveedor
|| oParteKardex.OperacionID == Cat.OperacionesKardex.SalidaInventario || oParteKardex.OperacionID == Cat.OperacionesKardex.SalidaTraspaso)
|| mCantidad *= -1;
*/
oParteKardex.ExistenciaNueva = (mExistencia + mCantidad);
Datos.Guardar <ParteKardex>(oParteKardex);
// Se valida la última entrada del kárdex con la existencia
/*
* var oParteEx = General.GetEntity<ParteExistencia>(c => c.ParteID == oParteKardex.ParteID && c.SucursalID == oParteKardex.SucursalID && c.Estatus);
* if (oParteKardex.ExistenciaNueva != oParteEx.Existencia)
* UtilLocal.MensajeError(string.Format("Hay una diferencia entre la existencia del Kárdex y la existencia del sistema. ¡Verificar!"
+ "\n\nExistencia Kárdex: {0}\nExistencia Sistema: {1}", oParteKardex.ExistenciaNueva, oParteEx.Existencia));
*/
}
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 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 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 Dictionary <string, string> ValoresVarios(int iSucursalID, string sLike)
{
var Res = new Dictionary <string, string>();
var oConfigs = Datos.GetListOf <Configuracion>(q => q.Nombre.Contains(sLike) && q.SucursalID == iSucursalID);
foreach (var oConfig in oConfigs)
{
Res.Add(oConfig.Nombre, oConfig.Valor);
}
return(Res);
}
public static string VentaPagoVales(int iVentaPagoID)
{
string sVales = "";
var oDet = Datos.GetListOf <VentaPagoDetalle>(c => c.VentaPagoID == iVentaPagoID && c.TipoFormaPagoID == Cat.FormasDePago.Vale && c.Estatus);
foreach (var oReg in oDet)
{
sVales += string.Format(", {0}({1})", oReg.NotaDeCreditoID, oReg.Importe.ToString(Con.Formatos.Moneda));
}
sVales = (sVales == "" ? "" : sVales.Substring(2));
return(sVales);
}
public static void EliminarPagosVenta(int iVentaID)
{
var oPagos = Datos.GetListOf <VentaPago>(c => c.VentaID == iVentaID && c.Estatus);
foreach (var oPago in oPagos)
{
var oPagoDet = Datos.GetListOf <VentaPagoDetalle>(c => c.VentaPagoID == oPago.VentaPagoID && c.Estatus);
foreach (var oPagoForma in oPagoDet)
{
Datos.Eliminar <VentaPagoDetalle>(oPagoForma, true);
}
Datos.Eliminar <VentaPago>(oPago, true);
}
}
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 CopiarPartesComplementariasDeEquivalentes(int iParteID)
{
var oPartesEq = Datos.GetListOf <PartesEquivalentesView>(c => c.ParteID == iParteID);
var oPartesCom = Datos.GetListOf <PartesComplementariasView>(c => c.ParteID == iParteID);
foreach (var oParteEq in oPartesEq)
{
foreach (var oParteComp in oPartesCom)
{
Guardar.ParteComplementaria(oParteEq.ParteIDEquivalente, oParteComp.ParteIDComplementaria);
// Se verifica si se debe guardar la forma inversa
if (Datos.Exists <ParteComplementaria>(c => c.ParteID == oParteComp.ParteIDComplementaria && c.ParteIDComplementaria == iParteID))
{
Guardar.ParteComplementaria(oParteComp.ParteIDComplementaria, oParteEq.ParteIDEquivalente);
}
}
}
}
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 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 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 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));
}
public static ResAcc RecibirConteoInventario(int iUsuarioID, List <modConteoInventario> oConteo)
{
// Se obtiene la sucursal correspondiente a los conteos, pues debe ser la misma para todos
if (oConteo.Count <= 0)
{
return(new ResAcc());
}
int iPrimerInvID = oConteo[0].InventarioLineaID;
var oPrimerInv = Datos.GetEntity <InventarioLinea>(c => c.InventarioLineaID == iPrimerInvID);
int iSucursalID = oPrimerInv.SucursalID;
// Se registra lo del conteo
oConteo = oConteo.OrderBy(c => c.InventarioLineaID).ToList();
int iInventarioLineaID = 0;
List <InventarioLinea> oInvConteos = new List <InventarioLinea>();
InventarioLinea oInventarioLinea = null;
List <InventarioConteo> oDiferencias1 = new List <InventarioConteo>();
List <InventarioConteo> oDiferencias2 = new List <InventarioConteo>();
List <InventarioConteo> oDiferencias3 = new List <InventarioConteo>();
foreach (var oReg in oConteo)
{
if (oReg.InventarioLineaID != iInventarioLineaID)
{
oInventarioLinea = Datos.GetEntity <InventarioLinea>(c => c.InventarioLineaID == oReg.InventarioLineaID);
oInvConteos.Add(oInventarioLinea);
iInventarioLineaID = oReg.InventarioLineaID;
}
// Se obtiene el conteo y la existencia, para saber si hay diferencia
var oParteConteo = Datos.GetEntity <InventarioConteo>(c => c.InventarioConteoID == oReg.InventarioConteoID);
var oExistencia = Datos.GetEntity <ParteExistencia>(c => c.ParteID == oParteConteo.ParteID && c.SucursalID == oInventarioLinea.SucursalID && c.Estatus);
decimal mDiferencia = (oReg.Conteo - oExistencia.Existencia.Valor());
// Se evalua la diferencia
oParteConteo.Valido = true;
switch (oParteConteo.Revision)
{
case null:
case Cat.InventarioConteosRevisiones.SinRevision:
if (mDiferencia != 0)
{
oDiferencias1.Add(oParteConteo);
oParteConteo.Valido = false;
}
break;
case Cat.InventarioConteosRevisiones.Confirmacion:
var oParteConteoAnt = Datos.GetEntity <InventarioConteo>(c => c.InventarioLineaID == oParteConteo.InventarioLineaID && !c.Revision.HasValue);
if (oParteConteoAnt.Diferencia == mDiferencia)
{
oDiferencias3.Add(oParteConteo);
}
else
{
oDiferencias2.Add(oParteConteo);
oParteConteo.Valido = false;
}
break;
case Cat.InventarioConteosRevisiones.ConfirmacionGerente:
if (mDiferencia != 0)
{
oDiferencias3.Add(oParteConteo);
}
break;
}
// Se guarda la diferencia
oParteConteo.Diferencia = mDiferencia;
Datos.Guardar <InventarioConteo>(oParteConteo);
}
// Se obtienen los usuarios para inventario de todas las sucursales
var oUsuariosInv = Datos.GetListOf <InventarioUsuario>();
// Se obtienen los usuario para inventario de la sucursal
var oUsuariosSuc = oUsuariosInv.Where(c => c.SucursalID == iSucursalID).ToList();
int iCantidadPorUsuario = (oDiferencias1.Count / oUsuariosSuc.Count);
// Se agregan los conteos para revisión 1 (de confirmación)
int iUsuario = 0, iCantidad = 0;
foreach (var oReg in oDiferencias1)
{
var oNuevoConteo = new InventarioConteo()
{
InventarioLineaID = oReg.InventarioLineaID,
Dia = DateTime.Now.AddDays(1),
ConteoUsuarioID = oUsuariosSuc[iUsuario].InvUsuarioID,
ParteID = oReg.ParteID,
Revision = Cat.InventarioConteosRevisiones.Confirmacion
};
Datos.Guardar <InventarioConteo>(oNuevoConteo);
if (++iCantidad >= iCantidadPorUsuario)
{
if (++iUsuario >= oUsuariosSuc.Count)
{
iUsuario = 0;
}
}
}
// Se agregan los conteos para revisión 2 (confirmación del gerente)
var oSucursal = Datos.GetEntity <Sucursal>(c => c.SucursalID == iSucursalID && c.Estatus);
int iGerenteID = oSucursal.GerenteID;
foreach (var oReg in oDiferencias2)
{
var oNuevoConteo = new InventarioConteo()
{
InventarioLineaID = oReg.InventarioLineaID,
Dia = DateTime.Now,
ConteoUsuarioID = iGerenteID,
ParteID = oReg.ParteID,
Revision = Cat.InventarioConteosRevisiones.ConfirmacionGerente
};
Datos.Guardar <InventarioConteo>(oNuevoConteo);
}
// Se agregan los conteos para revisión 3 (otras sucursales si la existencia es 0)
var oIndiceUsuarioSucursal = new Dictionary <int, int>();
var oInvAbiertos = new List <int>(); // Para marcar como incompletos los inventarios que se "abran" por meter un nuevo conteo tipo 3
foreach (var oReg in oDiferencias3)
{
// Se valida si la existencia en otras sucursales es cero
var oExistencias = Datos.GetListOf <ParteExistencia>(c => c.ParteID == oReg.ParteID && c.SucursalID != iSucursalID);
foreach (var oExist in oExistencias)
{
if (oExist.Existencia == 0)
{
// Para determinar el usuario al cual asignar
oUsuariosSuc = oUsuariosInv.Where(c => c.SucursalID == oExist.SucursalID).ToList();
if (!oIndiceUsuarioSucursal.ContainsKey(oExist.SucursalID))
{
oIndiceUsuarioSucursal.Add(oExist.SucursalID, 0);
}
var oNuevoConteo = new InventarioConteo()
{
InventarioLineaID = oReg.InventarioLineaID,
Dia = DateTime.Now.AddDays(1),
ConteoUsuarioID = oUsuariosSuc[oIndiceUsuarioSucursal[oExist.SucursalID]].InvUsuarioID,
ParteID = oReg.ParteID,
Revision = Cat.InventarioConteosRevisiones.OtraSucursal
};
Datos.Guardar <InventarioConteo>(oNuevoConteo);
//
if (!oInvAbiertos.Contains(oReg.InventarioLineaID))
{
oInvAbiertos.Add(oReg.InventarioLineaID);
}
//
if (++oIndiceUsuarioSucursal[oExist.SucursalID] >= oUsuariosSuc.Count)
{
oIndiceUsuarioSucursal[oExist.SucursalID] = 0;
}
}
}
}
// Se marcan como incompletos los inventarios abiertos por este proceso
foreach (int iInvID in oInvAbiertos)
{
var oInv = Datos.GetEntity <InventarioLinea>(c => c.InventarioLineaID == iInvID);
oInv.EstatusGenericoID = Cat.EstatusGenericos.EnRevision;
oInv.FechaCompletado = null;
Datos.Guardar <InventarioLinea>(oInv);
}
// Se marcan como completado los inventarios ya concluidos, si hubiera
foreach (var oReg in oInvConteos)
{
var oInvConteoV = Datos.GetEntity <InventarioLineasConteosView>(c => c.InventarioLineaID == oReg.InventarioLineaID);
// Se valida si ya se completó el conteo
if (oInvConteoV.PartesLinea > oInvConteoV.Conteo)
{
continue;
}
else
{
oReg.EstatusGenericoID = Cat.EstatusGenericos.Completada;
oReg.FechaCompletado = DateTime.Now;
}
Datos.Guardar <InventarioLinea>(oReg);
}
return(new ResAcc());
}
/*
* public static ResAcc<int> GenerarNotaDeCredito(int iClienteID, decimal mImporte, string sObservacion)
* {
* return VentasProc.GenerarNotaDeCredito(iClienteID, mImporte, sObservacion, null);
* }
*
* public static ResAcc<int> GenerarNotaDeCredito(int iClienteID, decimal mImporte, string sObservacion, int? iOrigenVentaID)
* {
* DateTime dAhora = DateTime.Now;
*
* // Se revisa si existen otras notas de crédito que se puedan usar para afectar ésta
* bool bNegativa = (mImporte < 0);
* var oNotas = General.GetListOf<NotaDeCredito>(q => q.ClienteID == iClienteID && q.Valida && q.Estatus).OrderByDescending(q => q.FechaDeEmision);
* foreach (var oNota in oNotas)
* {
* if ((bNegativa && oNota.Importe < 0) || (!bNegativa && oNota.Importe > 0))
* continue;
*
* mImporte += oNota.Importe;
*
* if ((bNegativa && mImporte <= 0) || (!bNegativa && mImporte >= 0))
* //
* {
* oNota.Valida = false;
* oNota.FechaDeUso = dAhora;
* oNota.Observacion += ("\n\n" + DateTime.Now.ToString() + "Nota cancelada por ser descontada al agregar otra nota con un importe mayor.");
* Datos.Guardar<NotaDeCredito>(oNota);
* // Se debe imprimir algo aquí ?
*
* // Si ya se emparejó la cantidad, se sale
* if (mImporte == 0)
* return new ResAcc<int>(true, "");
* }
* else
* //
* {
* oNota.Importe += (mImporte * -1);
* Datos.Guardar<NotaDeCredito>(oNota);
* // Se debe imprimir algo aquí ?
*
* // Se sale, pues ya no hay importe para afectar
* return new ResAcc<int>(true, "");
* }
* }
*
* // Se crea la nota
* var oNotaNueva = new NotaDeCredito()
* {
* FechaDeEmision = DateTime.Now,
* Importe = mImporte,
* ClienteID = iClienteID,
* Valida = true,
* Observacion = sObservacion,
* OrigenVentaID = iOrigenVentaID
* };
* Datos.Guardar<NotaDeCredito>(oNotaNueva);
*
* // Se imprime el ticket correspondiente
*
*
* return new ResAcc<int>(true, oNotaNueva.NotaDeCreditoID);
* }
*/
#region [ Vales ]
public static ResAcc <int> GenerarNotaDeCredito(int iClienteID, decimal mImporte, string sObservacion, int iOrigenID, int iRelacionID)
{
DateTime dAhora = DateTime.Now;
// Se revisa si existen otras notas de crédito que se puedan usar para afectar ésta
bool bNegativa = (mImporte < 0);
var oNotas = Datos.GetListOf <NotaDeCredito>(q => q.ClienteID == iClienteID && q.Valida && q.Estatus).OrderByDescending(q => q.FechaDeEmision);
foreach (var oNota in oNotas)
{
if ((bNegativa && oNota.Importe < 0) || (!bNegativa && oNota.Importe > 0))
{
continue;
}
mImporte += oNota.Importe;
if ((bNegativa && mImporte <= 0) || (!bNegativa && mImporte >= 0))
//
{
oNota.Valida = false;
oNota.FechaDeUso = dAhora;
oNota.Observacion += ("\n\n" + DateTime.Now.ToString() + "Nota cancelada por ser descontada al agregar otra nota con un importe mayor.");
Datos.Guardar <NotaDeCredito>(oNota);
// Se debe imprimir algo aquí ?
// Si ya se emparejó la cantidad, se sale
if (mImporte == 0)
{
return(new ResAcc <int>(true, ""));
}
}
else
//
{
oNota.Importe += (mImporte * -1);
Datos.Guardar <NotaDeCredito>(oNota);
// Se debe imprimir algo aquí ?
// Se sale, pues ya no hay importe para afectar
return(new ResAcc <int>(true, ""));
}
}
// Se crea la nota
var oNotaNueva = new NotaDeCredito()
{
FechaDeEmision = DateTime.Now,
SucursalID = Theos.SucursalID,
Importe = mImporte,
ClienteID = iClienteID,
Valida = true,
Observacion = sObservacion,
OrigenID = iOrigenID,
RelacionID = iRelacionID
};
Datos.Guardar <NotaDeCredito>(oNotaNueva);
// Se imprime el ticket correspondiente
return(new ResAcc <int>(true, oNotaNueva.NotaDeCreditoID));
}
public static string GenerarFormaDePago(int iVentaID)
{
var oVentasP = Datos.GetListOf <VentasPagosDetalleView>(q => q.VentaID == iVentaID);
return(VentasProc.GenerarFormaDePago(oVentasP));
}
public static string VentaPagoFormasDePago(int iVentaPagoID)
{
var oPagos = Datos.GetListOf <VentaPagoDetalle>(q => q.VentaPagoID == iVentaPagoID && q.Estatus);
return(UtilDatos.VentaPagoFormasDePago(oPagos));
}
public static ResAcc VentaPago(VentaPago oPago, List <VentaPagoDetalle> Detalle)
{
// Se generan datos predeterminados o globales, en caso de que apliquen
oPago.Fecha = (oPago.Fecha != DateTime.MinValue ? oPago.Fecha : DateTime.Now);
oPago.SucursalID = (oPago.SucursalID > 0 ? oPago.SucursalID : Theos.SucursalID);
// Se guarda el pago
Datos.Guardar <VentaPago>(oPago);
// Se guarda el detalle
var oVentaV = Datos.GetEntity <VentasView>(q => q.VentaID == oPago.VentaID);
foreach (var PartePago in Detalle)
{
PartePago.VentaPagoID = oPago.VentaPagoID;
Datos.Guardar <VentaPagoDetalle>(PartePago);
// Se afectan las notas de crédito, si hay alguna
if (PartePago.TipoFormaPagoID == Cat.FormasDePago.Vale && PartePago.Importe > 0)
{
int iNotaID = PartePago.NotaDeCreditoID.Valor();
var oNota = Datos.GetEntity <NotaDeCredito>(q => q.NotaDeCreditoID == iNotaID && q.Estatus);
if (oNota != null)
{
// Se verifica si se usó el importe total o sólo una parte
if (PartePago.Importe < oNota.Importe)
{
// Se crea una nueva nota, con el importe restante
// 25/11/2015 - Se busca el vale original para usarlo como origen de todas las notas derivadas, en vez de el OrigenVentaID que se mandaba antes
int iOrigenValeID = (oNota.OrigenID == Cat.OrigenesNotaDeCredito.ImporteRestante ? oNota.RelacionID.Valor() : oNota.NotaDeCreditoID);
VentasProc.GenerarNotaDeCredito(oNota.ClienteID, (oNota.Importe - PartePago.Importe), "", Cat.OrigenesNotaDeCredito.ImporteRestante
, iOrigenValeID);
//
oNota.Importe = PartePago.Importe;
}
//
oNota.Valida = false;
oNota.FechaDeUso = DateTime.Now;
oNota.UsoVentaID = oPago.VentaID;
Datos.Guardar <NotaDeCredito>(oNota);
}
}
// Si es un pago bancario, se genera el movimiento correspondiente
if (PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta || PartePago.TipoFormaPagoID == Cat.FormasDePago.TarjetaDeDebito ||
PartePago.TipoFormaPagoID == Cat.FormasDePago.Transferencia || PartePago.TipoFormaPagoID == Cat.FormasDePago.Cheque)
{
var oBanco = Datos.GetEntity <Banco>(c => c.BancoID == PartePago.BancoID && c.Estatus);
var oMovBanc = new BancoCuentaMovimiento()
{
// BancoCuentaID = (PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta ? (int?)Cat.CuentasBancarias.Banamex : null),
EsIngreso = true,
Fecha = oPago.Fecha,
FechaAsignado = ((PartePago.TipoFormaPagoID == Cat.FormasDePago.Tarjeta || PartePago.TipoFormaPagoID == Cat.FormasDePago.TarjetaDeDebito)
? (DateTime?)oPago.Fecha : null),
SucursalID = oPago.SucursalID,
Importe = PartePago.Importe,
Concepto = oVentaV.Cliente,
Referencia = oVentaV.Folio,
TipoFormaPagoID = PartePago.TipoFormaPagoID,
DatosDePago = string.Format("{0}-{1}-{2}", oBanco.NombreBanco, PartePago.Folio, PartePago.Cuenta),
RelacionTabla = Cat.Tablas.VentaPagoDetalle,
RelacionID = PartePago.VentaPagoDetalleID,
};
ContaProc.RegistrarMovimientoBancario(oMovBanc);
}
}
// Se verifica el estatus de la venta, por si debe cambiar según el pago
if (oVentaV.VentaEstatusID == Cat.VentasEstatus.Cobrada)
{
// Se obtiene el total de los pagos
decimal mPagado = Datos.GetListOf <VentasPagosView>(q => q.VentaID == oVentaV.VentaID).Sum(q => q.Importe);
if (mPagado >= oVentaV.Total)
{
var oVenta = Datos.GetEntity <Venta>(q => q.Estatus && q.VentaID == oPago.VentaID);
oVenta.VentaEstatusID = Cat.VentasEstatus.Completada;
// Se guarda con el nuevo estatus
Datos.Guardar <Venta>(oVenta);
}
}
return(new ResAcc(true));
}
