private void btnCancelarFacPen_Click(object sender, EventArgs e)
{
if (this.dgvFacturasPorCancelar.CurrentRow == null)
{
UtilLocal.MensajeAdvertencia("No hay ninguna factura por cancelar seleccionada.");
return;
}
this.btnCancelarFacPen.Enabled = false;
Cargando.Mostrar();
int iVentaFacturaDevolucionID = Util.Entero(this.dgvFacturasPorCancelar.CurrentRow.Cells["VentaFacturaDevolucionID"].Value);
string sFolioFiscal = Util.Cadena(this.dgvFacturasPorCancelar.CurrentRow.Cells["FolioFiscal"].Value);
var Res = VentasLoc.GenerarFacturaCancelacion(sFolioFiscal, iVentaFacturaDevolucionID);
if (Res.Exito)
{
this.ActualizarFacturasPorCancelar();
Cargando.Cerrar();
}
else
{
Cargando.Cerrar();
UtilLocal.MensajeAdvertencia("Hubo un error al cancelar la factura:\n\n" + Res.Mensaje);
}
this.btnCancelarFacPen.Enabled = true;
}
private void btnNcAgregar_Click(object sender, EventArgs e)
{
// Se solicita el concepto e importe de la nota de crédito
string sConcepto = Util.Cadena(UtilLocal.ObtenerValor("Concepto de la Nota de Crédito:", "", MensajeObtenerValor.Tipo.TextoLargo));
if (sConcepto == "")
{
return;
}
decimal mImporte = Util.Decimal(UtilLocal.ObtenerValor("Importe de la Nota de Crédito:", "0.00", MensajeObtenerValor.Tipo.Decimal));
if (mImporte == 0)
{
return;
}
// Se solicita la autorización
var ResAut = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.NotasDeCredito.Agregar", "Autorización");
// Se genera la nota, si todo fue bien
if (ResAut.Exito)
{
var ResNC = VentasProc.GenerarNotaDeCredito(this.Cliente.ClienteID, mImporte, sConcepto, Cat.OrigenesNotaDeCredito.Directo, ResAut.Respuesta.UsuarioID);
// Se manda a crear la póliza contable correspondiente (AfeConta)
var oVale = Datos.GetEntity <NotaDeCredito>(c => c.NotaDeCreditoID == ResNC.Respuesta && c.Estatus);
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.ValeDirecto, oVale.NotaDeCreditoID, this.Cliente.Nombre, oVale.Observacion);
// Se guarda la autorización
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.NotaDeCreditoCrear, Cat.Tablas.NotaDeCredito, ResNC.Respuesta, ResAut.Respuesta.UsuarioID);
// Se manda imprimir el ticket correspondiente
VentasLoc.GenerarTicketNotaDeCredito(ResNC.Respuesta);
//
UtilLocal.MostrarNotificacion("Nota de Crédito generada correctamente.");
this.NcAplicarFiltro();
}
}
public override bool Ejecutar()
{
// Se verifica si es factura
int iVentaID = this.ctlBusqueda.VentaID;
var oVenta = Datos.GetEntity <VentasView>(q => q.VentaID == iVentaID);
if (oVenta.Facturada)
{
bool bImpresa = VentasLoc.ReimprimirFactura(oVenta.Folio);
if (!bImpresa)
{
return(false);
}
}
else
{
// Se manda a re-imprimir la venta seleccionada
var oAdicionales = new Dictionary <string, object>();
oAdicionales.Add("Cambio", 0);
VentasLoc.GenerarTicketDeVenta(oVenta.VentaID, null, oAdicionales);
}
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion("Procedimiento de guardado ejecutado..");
// Se limpia después de haberse guardado
this.Limpiar();
return(true);
}
public void GenerarCotizacion()
{
// Se guarda la cotización en la base de datos
var dAhora = DateTime.Now;
var oCot = new VentaCotizacion()
{
Fecha = dAhora,
SucursalID = GlobalClass.SucursalID,
ClienteID = this.oControlVentas.Cliente.ClienteID,
VendedorID = this.oControlVentas.ctlCobro.VendodorID
};
Datos.Guardar <VentaCotizacion>(oCot);
// Detalle
var oVentaDetalle = this.oControlVentas.GenerarVentaDetalle();
foreach (var oReg in oVentaDetalle)
{
var oParteCot = new VentaCotizacionDetalle()
{
VentaCotizacionID = oCot.VentaCotizacionID,
ParteID = oReg.ParteID,
Cantidad = oReg.Cantidad,
PrecioUnitario = oReg.PrecioUnitario,
Iva = oReg.Iva
};
Datos.Guardar <VentaCotizacionDetalle>(oParteCot);
}
// Para generar el ticket de la cotización
var oVendedor = Datos.GetEntity <Usuario>(q => q.UsuarioID == this.oControlVentas.ctlCobro.VendodorID && q.Estatus);
var oVentaV = new VentasView()
{
Fecha = dAhora,
Cliente = this.oControlVentas.Cliente.Nombre,
Vendedor = oVendedor.NombrePersona,
Total = this.oControlVentas.Total,
SucursalID = GlobalClass.SucursalID
};
List <VentasDetalleView> oVentaDetalleV = new List <VentasDetalleView>();
Parte oParte;
foreach (var oDet in oVentaDetalle)
{
oParte = Datos.GetEntity <Parte>(q => q.ParteID == oDet.ParteID && q.Estatus);
oVentaDetalleV.Add(new VentasDetalleView()
{
NumeroParte = oParte.NumeroParte,
NombreParte = oParte.NombreParte,
Cantidad = oDet.Cantidad,
PrecioUnitario = oDet.PrecioUnitario,
Iva = oDet.Iva
});
}
VentasLoc.GenerarTicketDeCotizacion(oVentaV, oVentaDetalleV);
}
private void txtReimpresion_KeyPress(object sender, KeyPressEventArgs e)
{
if (e.KeyChar == (char)Keys.Enter)
{
this.txtReimpresion.SelectAll();
string sFolioCob = this.txtReimpresion.Text;
var oCobranza = Datos.GetEntity <CobranzaTicket>(q => q.Ticket == sFolioCob);
if (oCobranza == null)
{
UtilLocal.MensajeAdvertencia("El folio de Cobranza especificado no existe.");
return;
}
VentasLoc.GenerarTicketCobranza(sFolioCob);
}
}
private void VerTicketDevolucion()
{
string sFolio = this.txtReimpresion.Text;
var oVenta = Datos.GetEntity <Venta>(c => c.Folio == sFolio && c.Estatus);
if (oVenta == null)
{
UtilLocal.MensajeAdvertencia("La venta especificada no existe.");
return;
}
// Se obtiene la devolución a reimprimir
var oDevs = Datos.GetListOf <VentasDevolucionesView>(c => c.VentaID == oVenta.VentaID);
int iDevID = 0;
if (oDevs.Count == 0)
{
UtilLocal.MensajeAdvertencia("La venta especificada no tiene devoluciones/cancelaciones.");
return;
}
else if (oDevs.Count > 1)
{
var frmListado = new SeleccionListado(oDevs);
frmListado.Text = "Selecciona una Devolución/Cancelación";
frmListado.MostrarColumnas("Fecha", "VentaDevolucionID", "Total");
frmListado.dgvListado.Columns["VentaDevolucionID"].HeaderText = "Folio Dev.";
frmListado.dgvListado.Columns["Total"].FormatoMoneda();
if (frmListado.ShowDialog(Principal.Instance) == DialogResult.OK)
{
iDevID = Util.Entero(frmListado.Seleccion["VentaDevolucionID"]);
}
frmListado.Dispose();
}
else
{
iDevID = oDevs[0].VentaDevolucionID;
}
// Se manda reimprimir
if (iDevID > 0)
{
VentasLoc.GenerarTicketDevolucion(iDevID);
this.txtReimpresion.Clear();
}
}
private static void oEscucha_ConexionRecibida(Socket oSocket, string sMensaje)
{
if (string.IsNullOrEmpty(sMensaje))
{
return;
}
string sCodigo = sMensaje.Substring(0, 2);
sMensaje = sMensaje.Substring(2);
switch (sCodigo)
{
case MensajesTcp.Alerta9500:
Util.MensajeInformacion(sMensaje, "Notificación");
break;
case MensajesTcp.DevolucionFacturaCreditoAnt:
int iDevolucionID = Util.Entero(sMensaje);
VentasLoc.MostrarAvisoDevolucionFacturaCreditoAnt(iDevolucionID);
break;
}
}
private bool AccionAceptar()
{
// Cargando.Mostrar();
decimal mFaltante = 0;
int iClienteID = 0;
int iCobroVentaID = 0;
bool bUsarCascosAFavor = false;
bool bCrearVale = false;
bool bCascoAFavor = false;
int iCascoRecibido = Util.Entero(this.cmbCascoRecibido.SelectedValue);
int iSucursalID = GlobalClass.SucursalID;
int iCascoRegistroID = this.oCascoRegistro.CascoRegistroID;
int iParteID = this.oCascoRegistro.ParteID;
var oParte = Datos.GetEntity <Parte>(c => c.ParteID == iParteID && c.Estatus);
var oVenta = Datos.GetEntity <Venta>(c => c.VentaID == this.oCascoRegistro.VentaID && c.Estatus);
iClienteID = oVenta.ClienteID;
var oCliente = Datos.GetEntity <Cliente>(c => c.ClienteID == oVenta.ClienteID && c.Estatus);
if (iCascoRecibido != oParte.RequiereCascoDe)
{
// Si se recibió algún casco
if (iCascoRecibido > 0)
{
// Se obtienen el importe requerido
var oPrecioReq = Datos.GetEntity <PartePrecio>(c => c.ParteID == oParte.RequiereCascoDe && c.Estatus);
var oPrecioRec = Datos.GetEntity <PartePrecio>(c => c.ParteID == iCascoRecibido && c.Estatus);
if (oPrecioReq == null || oPrecioRec == null)
{
UtilLocal.MensajeAdvertencia("Hubo un error al obtener el Casco requerido.");
return(false);
}
// Se calcula el importe faltante
decimal?[] aPreciosReq = new decimal?[5] {
oPrecioReq.PrecioUno, oPrecioReq.PrecioDos, oPrecioReq.PrecioTres, oPrecioReq.PrecioCuatro, oPrecioReq.PrecioCinco
};
decimal?[] aPreciosRec = new decimal?[5] {
oPrecioRec.PrecioUno, oPrecioRec.PrecioDos, oPrecioRec.PrecioTres, oPrecioRec.PrecioCuatro, oPrecioRec.PrecioCinco
};
mFaltante = (aPreciosReq[oCliente.ListaDePrecios - 1] - aPreciosRec[oCliente.ListaDePrecios - 1]).Valor();
// Se evalúa el importe faltante, para tomar alguna acción
if (mFaltante != 0)
{
// Si el casco recibido es menor que el casco esperado
if (mFaltante > 0)
{
// Se busca por folio de cobro o por cascos a favor, según sea el caso
if (this.txtFolioDeCobro.Text == "")
{
decimal mTotalAFavor = Util.Decimal(this.lblTotalAFavor.Text);
if (mTotalAFavor != mFaltante)
{
UtilLocal.MensajeAdvertencia("El importe seleccionado con los Cascos a favor debe ser de " + mFaltante.ToString(GlobalClass.FormatoMoneda));
return(false);
}
bUsarCascosAFavor = true;
}
else
{
// Se obtiene el importe de la venta
var oVentaCobroV = Datos.GetEntity <VentasView>(c => c.Folio == this.txtFolioDeCobro.Text && c.SucursalID == GlobalClass.SucursalID &&
(c.VentaEstatusID == Cat.VentasEstatus.Cobrada || c.VentaEstatusID == Cat.VentasEstatus.Completada));
if (oVentaCobroV == null)
{
UtilLocal.MensajeAdvertencia("La venta específicada no existe, no es de esta sucursal o no ha sido cobrada.");
return(false);
}
iCobroVentaID = oVentaCobroV.VentaID;
// Se valida que la parte de la venta sea una "diferencia de casco"
if (!Datos.Exists <VentaDetalle>(c => c.VentaID == iCobroVentaID && c.ParteID == Cat.Partes.DiferenciaDeCascos && c.Estatus))
{
UtilLocal.MensajeAdvertencia("La venta especificada no corresponde a una Diferencia de Casco.");
return(false);
}
// Se valida que el importe cobrado sea el correspondiente
if (oVentaCobroV.Total != mFaltante)
{
UtilLocal.MensajeAdvertencia("El cobro por la diferencia debe de ser de " + mFaltante.ToString(GlobalClass.FormatoMoneda));
return(false);
}
}
}
// Si el casco recibido es mayor que el casco esperado
else if (mFaltante < 0)
{
var oRes = UtilLocal.MensajePreguntaCancelar("El importe del casco recibido es mayor al esperado. ¿Deseas crear un Vale a favor del Cliente?");
if (oRes == DialogResult.Cancel)
{
return(false);
}
bCrearVale = (oRes == DialogResult.Yes);
bCascoAFavor = !bCrearVale;
}
}
}
else // Si no se recibió ningún casco, se evalúa la venta
{
// Se obtiene la VentaID
var oVentaCobro = Datos.GetEntity <Venta>(c => c.Folio == this.txtFolioDeCobro.Text && c.SucursalID == GlobalClass.SucursalID &&
(c.VentaEstatusID == Cat.VentasEstatus.Cobrada || c.VentaEstatusID == Cat.VentasEstatus.Completada) && c.Estatus);
if (oVentaCobro == null)
{
UtilLocal.MensajeAdvertencia("La venta específicada no existe, no es de esta sucursal o no ha sido cobrada.");
return(false);
}
iCobroVentaID = oVentaCobro.VentaID;
// Se valida que la venta tenga la Parte correspondiente al casco
if (!Datos.Exists <VentaDetalle>(c => c.VentaID == iCobroVentaID && c.ParteID == oParte.RequiereDepositoDe && c.Estatus))
{
UtilLocal.MensajeAdvertencia("El cobro del Casco no corresonde al Artículo.");
return(false);
}
}
}
// Cargando.Cerrar();
// Se solicita la contraseña
var oResU = UtilLocal.ValidarObtenerUsuario("Ventas.ControlDeCascos.Completar");
if (oResU.Error)
{
return(false);
}
Cargando.Mostrar();
// Se completa el registro de casco
DateTime dAhora = DateTime.Now;
// Se registran y modifican los Cascos a favor usados, si aplica
if (bUsarCascosAFavor)
{
foreach (DataGridViewRow oFila in this.dgvImportesAFavor.Rows)
{
if (Util.Logico(oFila.Cells["Sel"].Value))
{
// Se registra el importe usado para el CascoImporte
int iCascoImporteID = Util.Entero(oFila.Cells["CascoImporteID"].Value);
decimal mAUsar = Util.Decimal(oFila.Cells["ImporteAUsar"].Value);
var oCascoImporte = Datos.GetEntity <CascoImporte>(c => c.CascoImporteID == iCascoImporteID);
oCascoImporte.ImporteUsado += mAUsar;
Datos.Guardar <CascoImporte>(oCascoImporte);
// Se registra la relación entre el CascoRegistro y el CascoImporte
var oCascoRegImp = new CascoRegistroImporte()
{
CascoRegistroID = this.oCascoRegistro.CascoRegistroID,
CascoImporteID = oCascoImporte.CascoImporteID,
Importe = mAUsar
};
Datos.Guardar <CascoRegistroImporte>(oCascoRegImp);
}
}
}
// Se crea el vale, si aplica
if (bCrearVale)
{
var oRes = VentasProc.GenerarNotaDeCredito(iClienteID, (mFaltante * -1), "", Cat.OrigenesNotaDeCredito.CascoDeMayorValor
, this.oCascoRegistro.CascoRegistroID);
// Se crea la póliza contable (AfeConta)
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.ValeDirecto, oRes.Respuesta, oCliente.Nombre, "POR CASCO MAYOR");
// Se manda a imprimir el ticket
VentasLoc.GenerarTicketNotaDeCredito(oRes.Respuesta);
}
// Se registra el casco a favor, si aplica
if (bCascoAFavor)
{
var oCascoImporte = new CascoImporte()
{
Fecha = dAhora,
OrigenID = this.oCascoRegistro.CascoRegistroID,
Importe = (mFaltante * -1)
};
Datos.Guardar <CascoImporte>(oCascoImporte);
}
// Se afecta la existencia y el kárdex del casco recibido
if (iCascoRecibido > 0)
{
var oSucursal = Datos.GetEntity <Sucursal>(c => c.SucursalID == iSucursalID && c.Estatus);
var oPrecioRec = Datos.GetEntity <PartePrecio>(c => c.ParteID == iCascoRecibido && c.Estatus);
AdmonProc.AfectarExistenciaYKardex(iCascoRecibido, GlobalClass.SucursalID, Cat.OperacionesKardex.EntradaInventario, iCascoRegistroID.ToString()
, oResU.Respuesta.UsuarioID, oCliente.Nombre, "CONTROL DE CASCOS", oSucursal.NombreSucursal, 1, oPrecioRec.Costo.Valor()
, Cat.Tablas.CascoRegistro, iCascoRegistroID);
}
// Se guardan los datos del registro de casco
this.oCascoRegistro.RecibidoCascoID = (iCascoRecibido > 0 ? (int?)iCascoRecibido : null);
this.oCascoRegistro.RealizoUsuarioID = oResU.Respuesta.UsuarioID;
this.oCascoRegistro.CobroVentaID = (iCobroVentaID > 0 ? (int?)iCobroVentaID : null);
Datos.Guardar <CascoRegistro>(this.oCascoRegistro);
// Se manda a imprimir el ticket correspondiente
var oCascoRegV = Datos.GetEntity <CascosRegistrosView>(c => c.CascoRegistroID == iCascoRegistroID);
var oRep = new Report();
oRep.Load(GlobalClass.ConfiguracionGlobal.pathReportes + "ControlDeCascos.frx");
VentasLoc.TicketAgregarLeyendas(ref oRep);
oRep.RegisterData(new List <CascosRegistrosView>()
{
oCascoRegV
}, "ControlDeCasco");
UtilLocal.EnviarReporteASalida("Reportes.ControlDeCascos.Completar.Salida", oRep);
Cargando.Cerrar();
UtilLocal.MostrarNotificacion("Control de casco completado correctamente.");
return(true);
}
public override bool Ejecutar()
{
// Se verifica si ya se hizo el cierre de caja
if (UtilDatos.VerCierreDeDaja())
{
UtilLocal.MensajeAdvertencia("Ya se hizo el Corte de Caja. No se puede continuar.");
return(false);
}
// Se valida la parte de detalle
if (!this.ctlDetalle.Validar())
{
return(false);
}
// Se valida la parte de búsqueda
if (!this.ctlBusqueda.Validar())
{
return(false);
}
int iVentaID = this.ctlBusqueda.VentaID;
// Se valida que no sea una venta usada para cobro de Control de Cascos
if (Datos.Exists <CascosRegistrosView>(c => c.CobroVentaID == iVentaID &&
(c.VentaEstatusID != Cat.VentasEstatus.Cancelada && c.VentaEstatusID != Cat.VentasEstatus.CanceladaSinPago)))
{
UtilLocal.MensajeAdvertencia("La venta seleccionado fue utilizada para un cobro de Control de Cascos. No se puede cancelar.");
return(false);
}
//
bool bCancelacion = this.ctlDetalle.TodosMarcados();
var oVentaV = Datos.GetEntity <VentasView>(q => q.VentaID == iVentaID);
// Se verifica si es una cancelación de otra sucursal
if (oVentaV.SucursalID != GlobalClass.SucursalID)
{
if (UtilLocal.MensajePregunta("La Venta seleccionada es de otra Sucursal. ¿Deseas continuar?") != DialogResult.Yes)
{
return(false);
}
}
// Se verifica si es una cancelación de factura de varios tickets
int iVentaFacturaID = 0;
bool bFacturaMultiple = false;
bool bCancelarTodaLaFactura = this.ctlBusqueda.CancelarTodaLaFactura;
List <VentaFacturaDetalle> oVentasFactura = null;
if (oVentaV.Facturada)
{
iVentaFacturaID = Datos.GetEntity <VentaFacturaDetalle>(q => q.VentaID == oVentaV.VentaID && q.Estatus).VentaFacturaID;
oVentasFactura = Datos.GetListOf <VentaFacturaDetalle>(q => q.VentaFacturaID == iVentaFacturaID && q.Estatus);
bFacturaMultiple = (oVentasFactura.Count > 1);
// Se muestran los datos de detalle de todas las ventas de la factura
if (bCancelarTodaLaFactura && bFacturaMultiple)
{
if (!this.MostrarDetalleVentasFactura(oVentasFactura))
{
return(false);
}
}
}
// Se verifica si se creará vale, para pedir el cliente en caso de que no haya
int iValeClienteID = oVentaV.ClienteID;
if (this.ctlBusqueda.FormaDeDevolucion == Cat.FormasDePago.Vale && iValeClienteID == Cat.Clientes.Mostrador)
{
var frmValor = new MensajeObtenerValor("Selecciona el cliente para crear el Vale:", "", MensajeObtenerValor.Tipo.Combo);
frmValor.CargarCombo("ClienteID", "Nombre", Datos.GetListOf <Cliente>(q => q.ClienteID != Cat.Clientes.Mostrador && q.Estatus));
if (frmValor.ShowDialog(Principal.Instance) == DialogResult.OK)
{
iValeClienteID = Util.Entero(frmValor.Valor);
}
frmValor.Dispose();
if (iValeClienteID == 0)
{
return(false);
}
}
// Se pregunta el usuario que realiza la devolución
int iUsuarioID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario("Ventas.Devolucion.Agregar");
if (ResU.Error)
{
return(false);
}
iUsuarioID = ResU.Respuesta.UsuarioID;
// Se solicita la autorización
int iAutorizoID = 0;
ResU = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.Devoluciones.Agregar", "Autorización");
if (ResU.Exito)
{
iAutorizoID = ResU.Respuesta.UsuarioID;
}
// Se procede a guardar los cambios
DateTime dAhora = DateTime.Now;
// Si es factura múltiple, se cancelan todas las ventas de la factura, si no, sólo la venta seleccionada
var oIdsDev = new List <int>();
var oIdsCascos = new List <int>();
if (bFacturaMultiple && bCancelarTodaLaFactura)
{
var oDevGeneral = this.ctlBusqueda.GenerarDevolucion();
foreach (var oVentaFac in oVentasFactura)
{
// Se genera la devolución
var oDev = new VentaDevolucion()
{
VentaID = oVentaFac.VentaID,
Fecha = dAhora,
RealizoUsuarioID = iUsuarioID,
EsCancelacion = true,
MotivoID = oDevGeneral.MotivoID,
Observacion = oDevGeneral.Observacion,
TipoFormaPagoID = oDevGeneral.TipoFormaPagoID
};
// Se genera el detalle de la devolución
var oDevDet = new List <VentaDevolucionDetalle>();
var oVentaDetalle = Datos.GetListOf <VentaDetalle>(c => c.VentaID == oVentaFac.VentaID && c.Estatus);
foreach (var oParte in oVentaDetalle)
{
oDevDet.Add(new VentaDevolucionDetalle()
{
ParteID = oParte.ParteID,
Costo = oParte.Costo,
CostoConDescuento = oParte.CostoConDescuento,
Cantidad = oParte.Cantidad,
PrecioUnitario = oParte.PrecioUnitario,
Iva = oParte.Iva
});
}
// Se manda guardar la devolución
this.GuardarDevolucion(oDev, oDevDet, iValeClienteID);
// Se agrega a la lisa de devoluciones
oIdsDev.Add(oDev.VentaDevolucionID);
// Se verifica si requiere un casco
foreach (var oReg in oDevDet)
{
if (Datos.Exists <Parte>(c => c.ParteID == oReg.ParteID && c.RequiereCascoDe > 0 && c.Estatus))
{
oIdsCascos.Add(oReg.VentaDevolucionDetalleID);
}
}
}
}
else
{
// Se genera la devolución
var oDevolucion = this.ctlBusqueda.GenerarDevolucion();
oDevolucion.Fecha = dAhora;
oDevolucion.EsCancelacion = bCancelacion;
oDevolucion.RealizoUsuarioID = iUsuarioID;
// Se genera el detalle de la devolución
var oDevDetalle = new List <VentaDevolucionDetalle>();
var oProductos = this.ctlDetalle.ProductosSel();
foreach (var oProducto in oProductos)
{
oDevDetalle.Add(new VentaDevolucionDetalle()
{
ParteID = oProducto.ParteID,
Costo = oProducto.Costo,
CostoConDescuento = oProducto.CostoConDescuento,
Cantidad = oProducto.Cantidad,
PrecioUnitario = oProducto.PrecioUnitario,
Iva = oProducto.Iva
});
}
// Se guarda la devolución
this.GuardarDevolucion(oDevolucion, oDevDetalle, iValeClienteID);
//
oIdsDev.Add(oDevolucion.VentaDevolucionID);
// Se verifica si requiere un casco
foreach (var oReg in oDevDetalle)
{
if (Datos.Exists <Parte>(c => c.ParteID == oReg.ParteID && c.RequiereCascoDe > 0 && c.Estatus))
{
oIdsCascos.Add(oReg.VentaDevolucionDetalleID);
}
}
}
// Se verifica si es factura, en cuyo caso, se cancela la factura o se genera nota de crédito, según aplique
if (oVentaV.Facturada)
{
if (bCancelacion && (!bFacturaMultiple || (bFacturaMultiple && bCancelarTodaLaFactura)))
{
var ResFactura = VentasLoc.GenerarFacturaCancelacion(iVentaFacturaID, oIdsDev);
if (ResFactura.Error)
{
UtilLocal.MensajeAdvertencia("Hubo un error al cancelar la factura.\n\n" + ResFactura.Mensaje);
}
}
else
{
var ResFactura = VentasLoc.GenerarFacturaDevolucionPorDevolucion(oIdsDev[0]);
if (ResFactura.Error)
{
UtilLocal.MensajeAdvertencia("Hubo un error al generar la factura de la devolución.\n\n" + ResFactura.Mensaje);
}
}
}
// Se verifica si hay una cancelación de control de cascos
foreach (int iDevDetID in oIdsCascos)
{
this.DevolverControlCasco(iDevDetID, iUsuarioID);
}
// Se manda a afectar contabilidad (AfeConta)
foreach (int iDevID in oIdsDev)
{
var oDevV = Datos.GetEntity <VentasDevolucionesView>(c => c.VentaDevolucionID == iDevID);
if (oDevV.Facturada)
{
if (oDevV.VentaACredito)
{
if (oDevV.FormaDePagoID == Cat.FormasDePago.Vale)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaCreditoFacturadaVale, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
}
else
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaCreditoFacturadaPago, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
}
}
else
{
if (oDevV.FormaDePagoID == Cat.FormasDePago.Vale)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaValeFactura, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
}
else
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaPago, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
}
}
}
else
{
if (oDevV.FormaDePagoID == Cat.FormasDePago.Vale)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.DevolucionVentaValeTicket, iDevID, oDevV.FolioDeVenta, oDevV.Observacion);
}
// Si es tiecket a crédito, se hace ajuste temporal de pólizas
if (oDevV.VentaACredito)
{
ContaProc.BorrarPolizaTemporalTicketCredito(oDevV.VentaID);
if (!bCancelacion)
{
var oVentaVi = Datos.GetEntity <VentasView>(c => c.VentaID == oDevV.VentaID);
ContaProc.CrearPolizaTemporalTicketCredito(oDevV.VentaID, (oVentaVi.Total - oVentaVi.Pagado));
}
}
}
}
//
foreach (int iDevID in oIdsDev)
{
// Se guarda la autorización, si aplica
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.DevolucionCancelacion, Cat.Tablas.VentaDevolucion, iDevID, iAutorizoID);
// Se genera el ticket correspondiente
VentasLoc.GenerarTicketDevolucion(iDevID);
// Se agrega al Kardex
/* Ahora se hace desde que se guarda la devolución - Guardar.VentaDevolucion()
* var oDevV = General.GetEntity<VentasDevolucionesView>(c => c.VentaDevolucionID == iDevID);
* var oDet = General.GetListOf<VentaDevolucionDetalle>(c => c.VentaDevolucionID == iDevID && c.Estatus);
* foreach (var oReg in oDet)
* {
* AdmonProc.RegistrarKardex(new ParteKardex()
* {
* ParteID = oReg.ParteID,
* OperacionID = Cat.OperacionesKardex.VentaCancelada,
* SucursalID = oDevV.SucursalID,
* Folio = oDevV.FolioDeVenta,
* Fecha = DateTime.Now,
* RealizoUsuarioID = oDevV.RealizoUsuarioID,
* Entidad = oVentaV.Cliente,
* Origen = oVentaV.ClienteID.ToString(),
* Destino = oDevV.Sucursal,
* Cantidad = oReg.Cantidad,
* Importe = (oReg.PrecioUnitario + oReg.Iva),
* RelacionTabla = Cat.Tablas.VentaDevolucion,
* RelacionID = oDevV.VentaDevolucionID
* });
* }
*/
}
// Se manda aviso de cancelación de factura a crédito de días anteriores, si aplica
if (oVentaV.Facturada && oVentaV.ACredito && oVentaV.Fecha < DateTime.Now.Date)
{
var oUsuarios = Datos.GetListOf <Usuario>(c => c.AlertaDevFacturaCreditoAnt == true && c.Estatus);
foreach (var oReg in oUsuarios)
{
Proc.EnviarMensajeTcp(oReg.Ip, Proc.MensajesTcp.DevolucionFacturaCreditoAnt, oIdsDev[0].ToString());
}
}
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion((bCancelacion ? "Cancelación" : "Devolución") + " guardada correctamente.");
// Se limpia después de haberse guardado
this.Limpiar();
return(true);
}
public override bool Ejecutar()
{
// Se valida la opción
if (!this.ctlFacturar.Validar())
{
return(false);
}
// Se pregunta si se debe facturar al mismo cliente de las ventas o a otro
int iAFClienteID = this.Cliente.ClienteID;
if (UtilLocal.MensajePregunta("¿Deseas hacer la factura a nombre del cliente seleccionado?") == DialogResult.No)
{
iAFClienteID = 0;
var frmValor = new MensajeObtenerValor("Selecciona el cliente para facturar:", "", MensajeObtenerValor.Tipo.Combo);
frmValor.CargarCombo("ClienteID", "Nombre", Datos.GetListOf <Cliente>(q => q.ClienteID != Cat.Clientes.Mostrador && q.Estatus));
if (frmValor.ShowDialog(Principal.Instance) == DialogResult.OK)
{
iAFClienteID = Util.Entero(frmValor.Valor);
}
frmValor.Dispose();
}
if (iAFClienteID == 0)
{
return(false);
}
// Se solicita el usuario que realiza el proceso
int iUsuarioID = 0;
var Res = UtilLocal.ValidarObtenerUsuario("Ventas.FacturarTickets.Agregar");
if (Res.Error)
{
return(false);
}
iUsuarioID = Res.Respuesta.UsuarioID;
// Se muestra la ventana de "Cargando.."
Cargando.Mostrar();
//
DateTime dAhora = DateTime.Now;
// Se obtienen los datos de los productos, por si se cambió la descripción
List <ProductoVenta> oPartes = null;
if (this.ctlFacturar.MostrarTodasLasPartes)
{
oPartes = this.ctlDetalle.ObtenerListaVenta();
}
// Se procede a generar la factura
var oVentasAF = this.ctlFacturar.GenerarListaDeVentas();
var oFormasDePago = this.ctlFacturar.FormasDePagoLibre;
var ResFe = VentasLoc.GenerarFacturaElectronica(oVentasAF, iAFClienteID, oPartes, oFormasDePago, this.ctlFacturar.Observacion, null);
if (ResFe.Error)
{
UtilLocal.MensajeAdvertencia(ResFe.Mensaje);
return(false);
}
// Se guarda el dato de que fue una factura de ventas
var oFactura = Datos.GetEntity <VentaFactura>(q => q.VentaFacturaID == ResFe.Respuesta && q.Estatus);
oFactura.Convertida = true;
oFactura.RealizoUsuarioID = iUsuarioID;
Datos.Guardar <VentaFactura>(oFactura);
// Se manda a afectar contabilidad (AfeConta)
foreach (int iVentaID in oVentasAF)
{
var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == iVentaID);
if (oVentaV.ACredito)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.VentaCredito, iVentaID, (oFactura.Serie + oFactura.Folio), oVentaV.Cliente);
// Se verifica si el ticket ya está pagado, para hacer la póliza correspondiente a dicho pago
if (oVentaV.Pagado > 0)
{
var oPagos = Datos.GetListOf <VentaPago>(c => c.VentaID == iVentaID && c.Estatus);
foreach (var oReg in oPagos)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoVentaCredito, oReg.VentaPagoID
, ((oFactura.Serie + oFactura.Folio) + " / " + UtilDatos.VentaPagoFormasDePago(oReg.VentaPagoID))
, oVentaV.Cliente, oReg.SucursalID);
}
}
// Se borra la póliza temporal creada por ser ticket a crédito
ContaProc.BorrarPolizaTemporalTicketCredito(iVentaID);
}
else
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.VentaContadoFacturaConvertida, iVentaID
, (oFactura.Serie + oFactura.Folio), oVentaV.Cliente, oVentaV.SucursalID);
}
}
// Se guarda el dato de pendiente por descontar en la factura global, si aplica
// Se guardan datos cuando se están facturando tickets abonados en otras sucursales
foreach (int iVentaID in oVentasAF)
{
// Se obtienen los abonos de otras sucursales
var oAbonos = Datos.GetListOf <VentasPagosView>(c => c.VentaID == iVentaID && c.SucursalID != GlobalClass.SucursalID)
.GroupBy(c => new { c.VentaID, c.SucursalID }).Select(c => new { c.Key.VentaID, c.Key.SucursalID, Abonado = c.Sum(s => s.Importe) });
if (oAbonos != null && oAbonos.Count() > 0)
{
foreach (var oReg in oAbonos)
{
var oPendiente = new FacturaGlobalPendientePorDescontar()
{
VentaID = oReg.VentaID,
Fecha = dAhora,
SucursalID = oReg.SucursalID,
Importe = oReg.Abonado
};
Datos.Guardar <FacturaGlobalPendientePorDescontar>(oPendiente);
}
}
}
// Se cierra la ventana de "Cargando.."
Cargando.Cerrar();
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion("Procedimiento ejecutado correctamente.");
// Se limpia después de haberse guardado
this.Limpiar();
return(true);
}
public override bool Ejecutar()
{
// Se valida que el importe a pagar sea mayor que cero
if (this.ctlCobranza.Total <= 0)
{
UtilLocal.MensajeAdvertencia("No hay ningún importe a pagar.");
return(false);
}
// Se valida el cobro
if (!this.ctlCobro.Validar())
{
return(false);
}
// Se valida que el pago sea en la misma sucursal que el primer abono, si hubiera
var oVentasACobrar = this.ctlCobranza.ObtenerVentasMarcadas();
string sVentasOt = "";
foreach (var oReg in oVentasACobrar)
{
if (Datos.Exists <VentaPago>(c => c.VentaID == oReg.VentaID && c.Estatus && c.SucursalID != GlobalClass.SucursalID))
{
sVentasOt += (", " + oReg.Folio);
}
}
if (sVentasOt != "" && oVentasACobrar[0].VentaID != 270157) // Modificaciòn temporal para no evaluar esa venta - 2015-08-24
{
UtilLocal.MensajeAdvertencia("Las siguientes ventas ya fueron abonadas en otra sucursal, por lo tanto aquí no se pueden cobrar.\n\n"
+ sVentasOt.Substring(2));
return(false);
}
// Si se quiere pagar con Vales, se valida que sólo sea una venta
var oFormasDePago = this.ctlCobro.GenerarPagoDetalle();
if (oFormasDePago.Any(c => c.TipoFormaPagoID == Cat.FormasDePago.Vale) && oVentasACobrar.Count > 1)
{
UtilLocal.MensajeAdvertencia("En selecciones múltiples no se puede usar vales. Es necesario seleccionar sólo una venta.");
return(false);
}
// Confirmación
if (UtilLocal.MensajePregunta("¿Estás seguro que deseas realizar el abono indicado?") != DialogResult.Yes)
{
return(false);
}
// Se completa el cobro, por si fue pago en efectivo
if (!this.ctlCobro.CompletarCobro())
{
return(false);
}
// Se solicita la validación de autorización, si aplica
int iAutorizoID = 0;
if (this.ctlCobro.AutorizacionDeNotasDeCreditoRequerida)
{
var Res = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.Cobro.NotaDeCreditoOtroCliente", "Autorización");
iAutorizoID = (Res.Exito ? Res.Respuesta.UsuarioID : 0);
}
// Se procede a guardar los datos
DateTime dAhora = DateTime.Now;
// Se generan los pagos para las ventas marcadas, hasta donde alcance el importe
decimal mPago = this.ctlCobro.Suma;
var oVentasAfectadas = new List <VentasACreditoView>();
var oPagosDetalleGen = new List <VentaPagoDetalle>();
var oIdsPago = new List <int>();
foreach (var oVentaACobrar in oVentasACobrar)
{
// Si la venta no tiene saldo, se salta
if (oVentaACobrar.Restante <= 0)
{
continue;
}
var oPago = new VentaPago()
{
VentaID = oVentaACobrar.VentaID,
Fecha = dAhora,
};
var oPagoDetalle = new List <VentaPagoDetalle>();
decimal mPagoForma = 0;
oVentaACobrar.Pagado = 0; // Se hace cero para que sólo sume lo pagado en esta ocasión
foreach (var oFormaDePago in oFormasDePago)
{
mPagoForma = (oFormaDePago.Importe > oVentaACobrar.Restante ? oVentaACobrar.Restante : oFormaDePago.Importe);
if (oFormaDePago.Importe > 0)
{
oPagoDetalle.Add(new VentaPagoDetalle()
{
TipoFormaPagoID = oFormaDePago.TipoFormaPagoID,
Importe = mPagoForma,
BancoID = oFormaDePago.BancoID,
Folio = oFormaDePago.Folio,
Cuenta = oFormaDePago.Cuenta,
NotaDeCreditoID = oFormaDePago.NotaDeCreditoID
});
mPago -= mPagoForma;
oFormaDePago.Importe -= mPagoForma;
oVentaACobrar.Pagado += mPagoForma;
oVentaACobrar.Restante -= mPagoForma;
if (oVentaACobrar.Restante <= 0)
{
break;
}
}
}
Guardar.VentaPago(oPago, oPagoDetalle);
// Se agrega la venta actual a las ventas afectadas
oVentasAfectadas.Add(oVentaACobrar);
oIdsPago.Add(oPago.VentaPagoID);
oPagosDetalleGen.AddRange(oPagoDetalle);
if (mPago <= 0)
{
break;
}
}
// Se manda a generar la póliza contable (AfeConta)
foreach (int iPagoID in oIdsPago)
{
var oPagoV = Datos.GetEntity <VentasPagosView>(c => c.VentaPagoID == iPagoID);
if (oPagoV.Facturada)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.PagoVentaCredito, iPagoID
, (oPagoV.Folio + " / " + UtilDatos.VentaPagoFormasDePago(iPagoID)), oPagoV.Cliente);
}
// Si es tiecket a crédito, se hace ajuste de pólizas
if (!oPagoV.Facturada)
{
ContaProc.BorrarPolizaTemporalTicketCredito(oPagoV.VentaID);
var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == oPagoV.VentaID);
if (oVentaV.VentaEstatusID == Cat.VentasEstatus.Cobrada)
{
ContaProc.CrearPolizaTemporalTicketCredito(oPagoV.VentaID, (oVentaV.Total - oVentaV.Pagado));
}
}
}
// Se guardan la autorizaciones aplicables
if (this.ctlCobro.AutorizacionDeNotasDeCreditoRequerida)
{
// Se agrega una autorización por cada nota de otro cliente
var oNotasOC = this.ctlCobro.NotasDeCreditoOtrosClientes();
foreach (var oNotaOC in oNotasOC)
{
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.NotaDeCreditoOtroClienteUsar, Cat.Tablas.NotaDeCredito, oNotaOC, iAutorizoID);
}
}
// Se guardan los datos del cobro, para reimpresión de tickets
string sFolioCob = VentasProc.GenerarFolioDeCobranza();
int iCuenta = 0;
foreach (var oVentaAf in oVentasAfectadas)
{
Datos.Guardar <CobranzaTicket>(new CobranzaTicket()
{
Ticket = sFolioCob,
VentaID = oVentaAf.VentaID,
ClienteID = this.Cliente.ClienteID,
Folio = oVentaAf.Folio,
Fecha = oVentaAf.Fecha,
Vencimiento = oVentaAf.Vencimiento,
Total = oVentaAf.Total,
Pagado = oVentaAf.Pagado,
Restante = oVentaAf.Restante,
VentaPagoID = oIdsPago[iCuenta++]
});
}
// Se genera el ticket correspondiente
VentasLoc.GenerarTicketCobranza(sFolioCob);
// Si se pagó con vale, se verifica si se crearon nuevos vales por importes restantes. Y se mandan a imprimir
var oValesCreados = VentasProc.ObtenerValesCreados(oPagosDetalleGen);
foreach (var oReg in oValesCreados)
{
VentasLoc.GenerarTicketNotaDeCredito(oReg.NotaDeCreditoID);
}
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion("Procedimiento completado correctamente.");
// Se limpia después de haberse guardado
this.Limpiar();
return(true);
}
private void Ncf_CrearNotaDeCreditoFiscal()
{
// Se verifica si hay ventas seleccionadas
if (this.dgvNcf_Facturas.ContarIncidencias("Ncf_Aplicar", true) == 0)
{
UtilLocal.MensajeAdvertencia("No hay ninguna venta seleccionada.");
return;
}
// Se obtiene el concepto
var oConcepto = UtilLocal.ObtenerValor("Concepto de Nota de Crédito:", "", MensajeObtenerValor.Tipo.TextoLargo);
if (oConcepto == null)
{
return;
}
// Se valida el permiso
var oResU = UtilLocal.ValidarObtenerUsuario("Ventas.NotasDeCreditoFiscales.Agregar");
if (oResU.Error)
{
return;
}
int iUsuarioID = oResU.Respuesta.UsuarioID;
// Se solicita la validación de autorización
var oResA = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.NotasDeCreditoFiscales.Agregar", "Autorización");
int?iAutorizoID = (oResA.Respuesta == null ? null : (int?)oResA.Respuesta.UsuarioID);
// Se genera el detalle de la nota de crédito, para mandar a hacer la factura
decimal mTotal = 0;
var oNotaDetalle = new List <ProductoVenta>();
oNotaDetalle.Add(new ProductoVenta()
{
NombreDeParte = Util.Cadena(oConcepto), UnidadDeMedida = "."
});
// Se meten las facturas afectadas
foreach (DataGridViewRow oFila in this.dgvNcf_Facturas.Rows)
{
if (!Util.Logico(oFila.Cells["Ncf_Aplicar"].Value))
{
continue;
}
int iVentaID = Util.Entero(oFila.Cells["Ncf_VentaID"].Value);
decimal mImporte = Util.Decimal(oFila.Cells["Ncf_Diferencia"].Value);
mTotal += mImporte;
var oVenta = Datos.GetEntity <Venta>(c => c.VentaID == iVentaID && c.Estatus);
oNotaDetalle.Add(new ProductoVenta()
{
NumeroDeParte = iVentaID.ToString(), // Se usa para mete la VentaID
NombreDeParte = string.Format("FACTURA: {0}", oVenta.Folio), // Se usa para mostrar la factura
Cantidad = 1,
PrecioUnitario = UtilTheos.ObtenerPrecioSinIva(mImporte),
Iva = UtilTheos.ObtenerIvaDePrecio(mImporte),
UnidadDeMedida = "."
});
}
if (mTotal == 0)
{
return;
}
Cargando.Mostrar();
// Se manda hacer la nota de crédito fiscal
var oRes = VentasLoc.GenerarNotaDeCreditoFiscal(oNotaDetalle, this.Cliente.ClienteID, iUsuarioID);
if (oRes.Error)
{
Cargando.Cerrar();
UtilLocal.MensajeAdvertencia(string.Format("Ocurrió un error al hacer la Nota de Crédito Fiscal\n\n{0}", oRes.Mensaje));
return;
}
// Se modifica el detalle de la Nota de Crédito Fiscal, con datos adicionales de las ventas afectadas
var oNcVentas = Datos.GetListOf <NotaDeCreditoFiscalDetalle>(c => c.NotaDeCreditoFiscalID == oRes.Respuesta);
foreach (DataGridViewRow oFila in this.dgvNcf_Facturas.Rows)
{
if (!Util.Logico(oFila.Cells["Ncf_Aplicar"].Value))
{
continue;
}
int iVentaID = Util.Entero(oFila.Cells["Ncf_VentaID"].Value);
int iListaPre = Util.Entero(oFila.Cells["Ncf_ListaDePrecios"].Value);
var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == iVentaID);
var oNcVenta = oNcVentas.FirstOrDefault(c => c.VentaID == iVentaID);
if (oNcVenta == null)
{
continue;
}
oNcVenta.ListaDePreciosUsada = iListaPre;
oNcVenta.ImporteAntes = oVentaV.Total;
Datos.Guardar <NotaDeCreditoFiscalDetalle>(oNcVenta);
}
// Se descuenta el importe en cada artículo de las ventas afectadas
foreach (DataGridViewRow oFila in this.dgvNcf_Facturas.Rows)
{
if (!Util.Logico(oFila.Cells["Ncf_Aplicar"].Value))
{
continue;
}
int iVentaID = Util.Entero(oFila.Cells["Ncf_VentaID"].Value);
int iListaPre = Util.Entero(oFila.Cells["Ncf_ListaDePrecios"].Value);
var oPartes = Datos.GetListOf <VentaDetalle>(c => c.VentaID == iVentaID && c.Estatus);
decimal mPrecio = 0;
foreach (var oReg in oPartes)
{
var oPrecio = Datos.GetEntity <PartePrecio>(c => c.ParteID == oReg.ParteID && c.Estatus);
switch (iListaPre)
{
case 1: mPrecio = oPrecio.PrecioUno.Valor(); break;
case 2: mPrecio = oPrecio.PrecioDos.Valor(); break;
case 3: mPrecio = oPrecio.PrecioTres.Valor(); break;
case 4: mPrecio = oPrecio.PrecioCuatro.Valor(); break;
case 5: mPrecio = oPrecio.PrecioCinco.Valor(); break;
}
// Se calcula el Iva
oReg.PrecioUnitario = UtilTheos.ObtenerPrecioSinIva(mPrecio);
oReg.Iva = (mPrecio - oReg.PrecioUnitario);
Datos.Guardar <VentaDetalle>(oReg);
}
}
// Se crea la póliza contable correspondiente (AfeConta)
// Una póliza por cada venta afectada
var oNotaV = Datos.GetEntity <NotasDeCreditoFiscalesView>(c => c.NotaDeCreditoFiscalID == oRes.Respuesta);
foreach (var oReg in oNcVentas)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.NotaDeCreditoDescuentoVenta, oReg.NotaDeCreditoFiscalDetalleID
, (oNotaV.Serie + oNotaV.Folio), oNotaV.Cliente);
}
// Se guarda la autorización
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.NotaDeCreditoFiscalCrear, "NotaDeCreditoFiscal", oRes.Respuesta, iAutorizoID);
Cargando.Cerrar();
this.NcfLlenarFacturas();
}
private void VerTicketCasco()
{
int iCascoID = Util.Entero(this.txtReimpresion.Text);
VentasLoc.GenerarTicketCasco(iCascoID);
}
private bool AgregarGarantia()
{
// Se valida la parte de detalle
if (!this.ctlDetalle.Validar())
{
return(false);
}
// Se valida la parte de búsqueda
if (!this.ctlBusqueda.Validar())
{
return(false);
}
// Se valida que sólo esté seleccionada una parte
if (this.ctlDetalle.ProductosSel().Count > 1)
{
UtilLocal.MensajeAdvertencia("Debes seleccionar sólo un producto al hacer una garantía.");
return(false);
}
// Se verifica si se creará vale, para pedir el cliente en caso de que no haya
var oGarantia = this.ctlBusqueda.GenerarGarantia();
int iVentaID = this.ctlBusqueda.VentaID;
var oVentaV = Datos.GetEntity <VentasView>(q => q.VentaID == iVentaID);
int iValeClienteID = oVentaV.ClienteID;
if ((oGarantia.AccionID == Cat.VentasGarantiasAcciones.ArticuloNuevo || oGarantia.AccionID == Cat.VentasGarantiasAcciones.NotaDeCredito) &&
iValeClienteID == Cat.Clientes.Mostrador)
{
iValeClienteID = VentasLoc.ObtenerClienteID("Selecciona el cliente para crear el Vale:", false);
if (iValeClienteID == 0)
{
return(false);
}
}
// Se pregunta el usuario que realiza la devolución
int iUsuarioID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario("Ventas.Garantia.Agregar");
if (ResU.Error)
{
return(false);
}
iUsuarioID = ResU.Respuesta.UsuarioID;
// Se solicita la autorización
int iAutorizoID = 0;
ResU = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.Garantia.Agregar", "Autorización");
if (ResU.Exito)
{
iAutorizoID = ResU.Respuesta.UsuarioID;
}
// Se procede a guardar los cambios
DateTime dAhora = DateTime.Now;
// Se genera la garantía
oGarantia.Fecha = dAhora;
oGarantia.RealizoUsuarioID = iUsuarioID;
oGarantia.EstatusGenericoID = Cat.EstatusGenericos.Recibido;
// Se llenan los datos de la parte
var oProducto = this.ctlDetalle.ProductosSel()[0];
oGarantia.ParteID = oProducto.ParteID;
oGarantia.Costo = oProducto.Costo;
oGarantia.CostoConDescuento = oProducto.CostoConDescuento;
oGarantia.PrecioUnitario = oProducto.PrecioUnitario;
oGarantia.Iva = oProducto.Iva;
// Se guarda la garantía
Guardar.VentaGarantia(oGarantia);
// Si queda a revisión del proveedor, ya no se hace nada más que mandar el ticket
if (oGarantia.AccionID != Cat.VentasGarantiasAcciones.RevisionDeProveedor)
{
this.CompletarAccionGarantia(oGarantia.VentaGarantiaID, iValeClienteID);
}
// Se mete un registro en kárdex, en cero, sólo para mantener historial de la operación
var oKardex = new ParteKardex()
{
ParteID = oGarantia.ParteID,
OperacionID = Cat.OperacionesKardex.VentaCancelada,
SucursalID = oGarantia.SucursalID,
Folio = oVentaV.Folio,
Fecha = dAhora,
RealizoUsuarioID = iUsuarioID,
Entidad = oVentaV.Cliente,
Origen = oVentaV.Sucursal,
Destino = "GARANTÍA RECIBIDA",
Cantidad = 0,
Importe = (oGarantia.PrecioUnitario + oGarantia.Iva),
RelacionTabla = Cat.Tablas.VentaGarantia,
RelacionID = oGarantia.VentaGarantiaID
};
AdmonProc.RegistrarKardex(oKardex);
// Se guarda la autorización, si aplica
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.Garantia, Cat.Tablas.VentaGarantia, oGarantia.VentaGarantiaID, iAutorizoID);
// Se genera el ticket correspondiente
VentasLoc.GenerarTicketGarantia(oGarantia.VentaGarantiaID);
return(true);
}
private void CompletarAccionGarantia(int iGarantiaID, int?iValeClienteID)
{
var oGarantiaV = Datos.GetEntity <VentasGarantiasView>(c => c.VentaGarantiaID == iGarantiaID);
var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == oGarantiaV.VentaID);
int iVentaID = oVentaV.VentaID;
// Se cambia el estatus de la venta, cuando aplique (cuando ya no hay partes en el detalle de la venta)
if (!Datos.Exists <VentaDetalle>(c => c.VentaID == iVentaID && c.Estatus))
{
var oVenta = Datos.GetEntity <Venta>(c => c.VentaID == iVentaID && c.Estatus);
oVenta.VentaEstatusID = Cat.VentasEstatus.AGarantia;
Datos.Guardar <Venta>(oVenta);
}
// Se obtiene el importe a devolver, por si fue a crédito y no se ha pagado toda la venta
decimal mImporteDev = (oVentaV.Pagado > oGarantiaV.Total ? oGarantiaV.Total.Valor() : oVentaV.Pagado);
// Se genera nota de crédito o devolución de efectivo, u otro, según aplique
if (mImporteDev > 0)
{
ResAcc <int> oResPagoNeg = null;
switch (oGarantiaV.AccionID)
{
case Cat.VentasGarantiasAcciones.ArticuloNuevo:
case Cat.VentasGarantiasAcciones.NotaDeCredito:
// var oVenta = General.GetEntity<Venta>(q => q.Estatus && q.VentaID == iVentaID);
var oResVale = VentasProc.GenerarNotaDeCredito(iValeClienteID.Value, mImporteDev, "", Cat.OrigenesNotaDeCredito.Garantia
, oGarantiaV.VentaGarantiaID);
// Se genera el pago negativo por la nota de crédito generada
oResPagoNeg = VentasProc.GenerarPagoNegativoPorNotaDeCredito(iVentaID, mImporteDev, oResVale.Respuesta);
break;
case Cat.VentasGarantiasAcciones.Efectivo:
oResPagoNeg = VentasProc.GenerarDevolucionDeEfectivo(iVentaID, mImporteDev);
break;
case Cat.VentasGarantiasAcciones.Cheque:
case Cat.VentasGarantiasAcciones.Tarjeta:
case Cat.VentasGarantiasAcciones.TarjetaDeDebito:
case Cat.VentasGarantiasAcciones.Transferencia:
int iFormaDePagoID = UtilDatos.FormaDePagoDeAccionGarantia(oGarantiaV.AccionID);
var oVentaPago = Datos.GetEntity <VentaPago>(q => q.VentaID == iVentaID && q.Estatus);
var oFormaPago = Datos.GetEntity <VentaPagoDetalle>(q =>
q.VentaPagoID == oVentaPago.VentaPagoID && q.TipoFormaPagoID == iFormaDePagoID && q.Estatus);
// Se genera un pago negativo con la misma forma del pago a contrarestar
oResPagoNeg = VentasProc.GenerarPago(iVentaID, (oFormaPago.Importe * -1), iFormaDePagoID, oFormaPago.BancoID.Valor(), oFormaPago.Folio, oFormaPago.Cuenta);
break;
}
// Se guarda el dato del pago negativo correspondiente a la devolución, si aplica
if (oResPagoNeg != null)
{
var oGarantia = Datos.GetEntity <VentaGarantia>(c => c.VentaGarantiaID == iGarantiaID && c.Estatus);
// Se obtiene el primer registro de VentaPagoDetalle, y ese es el que se relaciona con la garantía, pues se supone que siempre habrá sólo uno
var oPagoDet = Datos.GetEntity <VentaPagoDetalle>(c => c.VentaPagoID == oResPagoNeg.Respuesta && c.Estatus);
oGarantia.VentaPagoDetalleID = oPagoDet.VentaPagoDetalleID;
Datos.Guardar <VentaGarantia>(oGarantia);
}
}
// Se verifica si es factura, en cuyo caso, se genera nota de crédito, según aplique
if (oVentaV.Facturada)
{
var ResFactura = VentasLoc.GenerarFacturaDevolucionPorGarantia(iGarantiaID);
if (ResFactura.Error)
{
UtilLocal.MensajeAdvertencia("Hubo un error al generar la factura de la devolución.\n\n" + ResFactura.Mensaje);
}
}
// Se crea la póliza contable correspondiente, según el caso (AfeConta)
if (oVentaV.Facturada)
{
if (oVentaV.ACredito)
{
if (oGarantiaV.AccionID == Cat.VentasGarantiasAcciones.ArticuloNuevo || oGarantiaV.AccionID == Cat.VentasGarantiasAcciones.NotaDeCredito)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GarantiaVentaCreditoFacturaVale, oGarantiaV.VentaGarantiaID
, oGarantiaV.FolioDeVenta, oGarantiaV.MotivoObservacion);
}
else
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GarantiaVentaCreditoFacturadaPago, oGarantiaV.VentaGarantiaID
, oGarantiaV.FolioDeVenta, oGarantiaV.MotivoObservacion);
}
}
else
{
if (oGarantiaV.AccionID == Cat.VentasGarantiasAcciones.ArticuloNuevo || oGarantiaV.AccionID == Cat.VentasGarantiasAcciones.NotaDeCredito)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GarantiaVentaValeFactura, oGarantiaV.VentaGarantiaID
, oGarantiaV.FolioDeVenta, oGarantiaV.MotivoObservacion);
}
else
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GarantiaVentaPagoFactura, oGarantiaV.VentaGarantiaID
, oGarantiaV.FolioDeVenta, oGarantiaV.MotivoObservacion);
}
}
}
else
{
if (oGarantiaV.AccionID == Cat.VentasGarantiasAcciones.ArticuloNuevo || oGarantiaV.AccionID == Cat.VentasGarantiasAcciones.NotaDeCredito)
{
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.GarantiaVentaValeTicket, oGarantiaV.VentaGarantiaID
, oGarantiaV.FolioDeVenta, oGarantiaV.MotivoObservacion);
}
// Si es tiecket a crédito, se hace ajuste temporal de pólizas
if (oVentaV.ACredito)
{
ContaProc.BorrarPolizaTemporalTicketCredito(iVentaID);
// Se actualizan los datos de la venta
oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == iVentaID);
ContaProc.CrearPolizaTemporalTicketCredito(iVentaID, (oVentaV.Total - oVentaV.Pagado));
}
}
}
private bool CompletarGarantia()
{
// Se valida la parte de búsqueda
if (!this.ctlBusqueda.ValidarPendiente())
{
return(false);
}
//
int iGarantiaID = this.ctlBusqueda.SeleccionGarantiaID;
var oGarantia = Datos.GetEntity <VentaGarantia>(c => c.VentaGarantiaID == iGarantiaID && c.Estatus);
var oVentaV = Datos.GetEntity <VentasView>(c => c.VentaID == oGarantia.VentaID);
// Se verifica si se creará vale, para pedir el cliente en caso de que no haya
int iValeClienteID = oVentaV.ClienteID;
if ((this.ctlBusqueda.IdAccionPosterior == Cat.VentasGarantiasAcciones.ArticuloNuevo ||
this.ctlBusqueda.IdAccionPosterior == Cat.VentasGarantiasAcciones.NotaDeCredito) && iValeClienteID == Cat.Clientes.Mostrador)
{
iValeClienteID = VentasLoc.ObtenerClienteID("Selecciona el cliente para crear el Vale:", false);
if (iValeClienteID == 0)
{
return(false);
}
}
// Se pregunta el usuario que realiza la devolución
int iUsuarioID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario("Ventas.Garantia.Agregar");
if (ResU.Error)
{
return(false);
}
iUsuarioID = ResU.Respuesta.UsuarioID;
// Se solicita la autorización
int iAutorizoID = 0;
ResU = UtilLocal.ValidarObtenerUsuario("Autorizaciones.Ventas.Garantia.Agregar", "Autorización");
if (ResU.Exito)
{
iAutorizoID = ResU.Respuesta.UsuarioID;
}
// Se procede a guardar los cambios
DateTime dAhora = DateTime.Now;
// Se completan los datos de la garantía
oGarantia.AccionID = this.ctlBusqueda.IdAccionPosterior;
oGarantia.FechaCompletado = dAhora;
oGarantia.EstatusGenericoID = Cat.EstatusGenericos.Completada;
if (this.ctlBusqueda.AccionObservacion != "")
{
oGarantia.ObservacionCompletado += (" - " + this.ctlBusqueda.AccionObservacion);
}
// Se guardan los datos
Datos.Guardar <VentaGarantia>(oGarantia);
// Si queda a revisión del proveedor, ya no se hace nada más que mandar el ticket
if (oGarantia.AccionID != Cat.VentasGarantiasAcciones.NoProcede)
{
// Se borra la parte de la venta, pues ya se hizo válida la garantia
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);
}
//
this.CompletarAccionGarantia(iGarantiaID, iValeClienteID);
}
// Se guarda la autorización, si aplica
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.Garantia, Cat.Tablas.VentaGarantia, oGarantia.VentaGarantiaID, iAutorizoID);
// Se genera el ticket correspondiente
VentasLoc.GenerarTicketGarantia(oGarantia.VentaGarantiaID);
return(true);
}