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 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 realiza la acción según el caso
bool bResultado;
if (this.ctlBusqueda.GarantiaNueva)
{
bResultado = this.AgregarGarantia();
}
else
{
bResultado = this.CompletarGarantia();
}
if (!bResultado)
{
return(false);
}
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion("Garantía guardada correctamente.");
// Se limpia después de haberse guardado
this.Limpiar();
return(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();
}
}
private void btnGuardar_Click(object sender, System.EventArgs e)
{
// Se solicita contraseña del Usuario
var Res = UtilLocal.ValidarObtenerUsuario("Ventas.ReporteDeFaltante.Agregar");
if (Res.Error)
{
return;
}
ReporteDeFaltante Faltante = new ReporteDeFaltante()
{
SucursalID = GlobalClass.SucursalID
, RealizoUsuarioID = Res.Respuesta.UsuarioID
, ParteID = this.oParte.ParteID
, CantidadRequerida = (int)this.nudCantidad.Value
, Comentario = this.txtComentario.Text
};
Datos.Guardar <ReporteDeFaltante>(Faltante);
UtilLocal.MostrarNotificacion("Reporte guardado correctamente.");
this.Dispose();
}
public override bool Ejecutar()
{
// Se verifica si es
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion("No hay acción configurada para esta opción.");
// Se limpia después de haberse guardado
// this.Limpiar();
return(false);
}
private void btnAplicar_Click(object sender, System.EventArgs e)
{
// Se solicita contraseña del Usuario
var ValUsr = UtilLocal.ValidarObtenerUsuario("AplicarPartes.Agregar");
if (ValUsr.Error)
{
return;
}
// Se procede a guardar los datos
int? oMotorID = null, oAnio = null;
ParteVehiculo ParteV;
for (int iFila = 0; iFila < this.dgvPartes.Rows.Count; iFila++)
{
if (Util.Logico(this.dgvPartes["Aplicar", iFila].Value))
{
if (this.oVehiculo.MotorID > 0)
{
oMotorID = this.oVehiculo.MotorID;
}
if (this.oVehiculo.Anio > 0)
{
oAnio = this.oVehiculo.Anio;
}
ParteV = new ParteVehiculo()
{
ParteID = Util.Entero(this.dgvPartes["ParteID", iFila].Value)
, ModeloID = this.oVehiculo.ModeloID
, MotorID = oMotorID
, Anio = oAnio
, TipoFuenteID = Cat.TipoDeFuentes.Mostrador
, RegistroUsuarioID = ValUsr.Respuesta.UsuarioID
};
var Res = Guardar.ParteVehiculo(ParteV);
if (Res.Exito)
{
UtilLocal.MostrarNotificacion("Aplicación guardada exitosamente.");
}
else
{
UtilLocal.MostrarNotificacion(Res.Mensaje);
}
}
}
this.Close();
}
private bool AccionGuardar()
{
if (!this.Validar())
{
return(false);
}
Cargando.Mostrar();
switch (this.TipoCuenta)
{
case Tipo.Cuenta:
var oCuenta = (this.EsMod ? (this.oCuenta as ContaCuenta) : (new ContaCuenta()));
oCuenta.Cuenta = this.txtCuenta.Text;
oCuenta.CuentaContpaq = this.txtCuentaContpaq.Text;
oCuenta.CuentaSat = this.txtCuentaSat.Text;
Datos.Guardar <ContaCuenta>(oCuenta);
break;
case Tipo.Subcuenta:
var oSubcuenta = (this.EsMod ? (this.oCuenta as ContaSubcuenta) : (new ContaSubcuenta()));
oSubcuenta.ContaCuentaID = (this.EsMod ? oSubcuenta.ContaCuentaID : this.CuentaPadreID);
oSubcuenta.Subcuenta = this.txtCuenta.Text;
oSubcuenta.CuentaContpaq = this.txtCuentaContpaq.Text;
oSubcuenta.CuentaSat = this.txtCuentaSat.Text;
Datos.Guardar <ContaSubcuenta>(oSubcuenta);
break;
case Tipo.CuentaDeMayor:
var oCuentaMay = (this.EsMod ? (this.oCuenta as ContaCuentaDeMayor) : (new ContaCuentaDeMayor()));
oCuentaMay.ContaSubcuentaID = (this.EsMod ? oCuentaMay.ContaSubcuentaID : this.CuentaPadreID);
oCuentaMay.CuentaDeMayor = this.txtCuenta.Text;
oCuentaMay.CuentaContpaq = this.txtCuentaContpaq.Text;
oCuentaMay.CuentaSat = this.txtCuentaSat.Text;
oCuentaMay.RestaInversa = this.chkRestaInversa.Checked;
Datos.Guardar <ContaCuentaDeMayor>(oCuentaMay);
break;
case Tipo.CuentaAuxiliar:
this.GuardarCuentaAuxiliar();
break;
}
// Se muestra una notificación
UtilLocal.MostrarNotificacion("Proceso completado correctamente.");
Cargando.Cerrar();
return(true);
}
protected override void btnGuardar_Click(object sender, EventArgs e)
{
if (!this.Validar())
{
return;
}
this.oCambio.Fecha = this.dtpFecha.Value;
this.oCambio.Version = this.txtVersion.Text;
this.oCambio.Categoria = this.txtCategoria.Text;
this.oCambio.Modificacion = this.txtModificacion.Text;
this.oCambio.Observaciones = this.txtObservaciones.Text;
Datos.Guardar <CambioSistema>(this.oCambio);
UtilLocal.MostrarNotificacion("Cambio guardado correctamente.");
this.DialogResult = DialogResult.OK;
this.Close();
}
private void ImprimirEtiquetas(string sReporte)
{
// Se muestra progreso de avance
this.IniciarTerminarProgreso(true);
// Se inicia el proceso de impresión
Datos.StartPersistentContext();
foreach (DataGridViewRow oFila in this.dgvDatos.Rows)
{
this.pgrGuardar.EjecutarPaso(true);
if (!Util.Logico(oFila.Cells["Procesar"].Value))
{
continue;
}
int iParteID = Util.Entero(oFila.Cells["ParteID"].Value);
var oParte = Datos.GetEntity <Parte>(c => c.ParteID == iParteID && c.Estatus);
var oEtiqueta = new Etiquetas()
{
ParteID = iParteID,
NumeroParte = oParte.NumeroParte,
NombreParte = oParte.NombreParte,
CodigoBarra = oParte.CodigoBarra
};
// Se manda imprimir el reporte
var oRep = new FastReport.Report();
oRep.Load(sReporte);
oRep.RegisterData(new List <Etiquetas>()
{
oEtiqueta
}, "etiquetas");
oRep.Print();
}
Datos.EndPersistentContext();
this.IniciarTerminarProgreso(false);
UtilLocal.MostrarNotificacion("Proceso completado correctamente.");
}
public bool AccionGuardar()
{
// Se valida
if (!this.Validar())
{
return(false);
}
Cargando.Mostrar();
// Se guardan los datos
// DateTime dAhora = DateTime.Now;
int?iDocID = Util.Entero(this.cmbDocumento.SelectedValue);
// Se guarda el gasto
ContaEgreso oGasto = (this.EsMod ? this.oEgreso : new ContaEgreso());
oGasto.ContaCuentaAuxiliarID = Util.Entero(this.cmbCuentaAuxiliar.SelectedValue);
oGasto.Fecha = this.dtpFecha.Value;
oGasto.Importe = Util.Decimal(this.txtImporte.Text);
oGasto.TipoFormaPagoID = Util.Entero(this.cmbFormaDePago.SelectedValue);
oGasto.FolioDePago = this.txtFolioDePago.Text;
oGasto.FolioFactura = this.txtFolioFactura.Text;
oGasto.BancoCuentaID = (int?)this.cmbCuentaBancaria.SelectedValue;
oGasto.TipoDocumentoID = (iDocID > 0 ? iDocID : null);
oGasto.EsFiscal = this.chkEsFiscal.Checked;
oGasto.Observaciones = this.txtObservaciones.Text;
oGasto.RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID;
oGasto.SucursalID = GlobalClass.SucursalID;
Datos.Guardar <ContaEgreso>(oGasto);
// Se guarda el detalle, si aplica
foreach (DataGridViewRow Fila in this.dgvDetalle.Rows)
{
if (Fila.IsNewRow)
{
continue;
}
int iCambioID = Util.Entero(Fila.Cells["_Cambio"].Value);
if (iCambioID == Cat.TiposDeAfectacion.SinCambios)
{
continue;
}
ContaEgresoDetalle oGastoDet;
if (iCambioID == Cat.TiposDeAfectacion.Agregar)
{
oGastoDet = new ContaEgresoDetalle();
oGastoDet.ContaEgresoID = oGasto.ContaEgresoID;
}
else
{
oGastoDet = (Fila.Tag as ContaEgresoDetalle);
if (iCambioID == Cat.TiposDeAfectacion.Borrar)
{
Datos.Eliminar <ContaEgresoDetalle>(oGastoDet, true);
continue;
}
}
oGastoDet.ContaConsumibleID = Util.Entero(Fila.Cells["ContaConsumibleID"].Value);
oGastoDet.Cantidad = Util.Decimal(Fila.Cells["Cantidad"].Value);
oGastoDet.Importe = Util.Decimal(Fila.Cells["Precio"].Value);
Datos.Guardar <ContaEgresoDetalle>(oGastoDet);
}
// Se manda devengar automáticamente, si aplica
ContaProc.GastoVerDevengarAutomaticamente(oGasto);
// Se ejecutan procesos para gastos nuevos únicamente
if (!this.EsMod)
{
// Se crean la pólizas contable correspondientes (AfeConta),
ContaProc.CrearPolizasDeGastoContable(oGasto);
// Se crea el movimiento bancario correspondiente, si aplica
// Como se afecta la cuenta de bancos, se crea el movimiento bancario para mandarlo a conciliación y así llevar el control de todos los
// movimientos bancarios
if (oGasto.TipoFormaPagoID == Cat.FormasDePago.Cheque || oGasto.TipoFormaPagoID == Cat.FormasDePago.Tarjeta ||
oGasto.TipoFormaPagoID == Cat.FormasDePago.Transferencia)
{
var oMovBanc = new BancoCuentaMovimiento()
{
BancoCuentaID = oGasto.BancoCuentaID,
EsIngreso = false,
Fecha = oGasto.Fecha,
FechaAsignado = oGasto.Fecha,
SucursalID = oGasto.SucursalID,
Importe = oGasto.Importe,
Concepto = oGasto.Observaciones,
Referencia = oGasto.FolioFactura,
TipoFormaPagoID = oGasto.TipoFormaPagoID,
RelacionTabla = Cat.Tablas.ContaEgreso,
RelacionID = oGasto.ContaEgresoID
};
ContaProc.RegistrarMovimientoBancario(oMovBanc);
}
}
Cargando.Cerrar();
// Se muestra una notificación
this.RestaurarControles();
UtilLocal.MostrarNotificacion("Proceso completado correctamente.");
return(true);
}
private void GuardarDatos()
{
// Se inicializa el proceso de guardado, si aplica
if (this.IndiceGuardado == 0)
{
if (this.dgvDatos.Rows.Count <= 0)
{
return;
}
this.btnMostrar.Enabled = false;
this.btnProcesar.Enabled = false;
this.btnGuardar.Enabled = false;
//
this.pgbGuardado.Maximum = this.dgvDatos.Rows.Count;
this.pgbGuardado.Value = 0;
this.lblGuardadas.Text = "0";
this.lblTotalPartes.Text = this.dgvDatos.Rows.Count.ToString(GlobalClass.FormatoEntero);
this.btnPausar.Enabled = true;
this.btnPausar.Tag = false;
this.pnlGuardado.Visible = true;
// Se deshabilita el "Sort" de las columnas
foreach (DataGridViewColumn oCol in this.dgvDatos.Columns)
{
oCol.SortMode = DataGridViewColumnSortMode.NotSortable;
}
}
// Se inicia el proceso
Datos.StartPersistentContext();
DataGridViewRow Fila;
int iParteID;
ParteAbc oParte;
int iFilas = this.dgvDatos.Rows.Count;
for (int iFila = this.IndiceGuardado; iFila < iFilas; iFila++)
{
Fila = this.dgvDatos.Rows[iFila];
iParteID = Util.Entero(Fila.Cells["ParteID"].Value);
oParte = Datos.GetEntity <ParteAbc>(q => q.ParteID == iParteID);
// Si no existe, se crea
if (oParte == null)
{
oParte = new ParteAbc()
{
ParteID = iParteID
}
}
;
//
oParte.AbcDeVentas = (string)Fila.Cells["AbcDeVentas"].Value;
oParte.AbcDeUtilidad = (string)Fila.Cells["AbcDeUtilidad"].Value;
oParte.AbcDeNegocio = (string)Fila.Cells["AbcDeNegocio"].Value;
oParte.AbcDeProveedor = (string)Fila.Cells["AbcDeProveedor"].Value;
oParte.AbcDeLinea = (string)Fila.Cells["AbcDeLinea"].Value;
Datos.Guardar <ParteAbc>(oParte);
// Se reporta el progreso y se ejecutan los eventos (para que la aplicación no se trabe)
this.IndiceGuardado = iFila;
this.pgbGuardado.Value = (iFila + 1);
this.lblGuardadas.Text = (iFila + 1).ToString(GlobalClass.FormatoEntero);
Application.DoEvents();
if (this.PausaSolicitada)
{
return;
}
}
Datos.EndPersistentContext();
// Se finaliza
this.IndiceGuardado = 0;
this.btnMostrar.Enabled = true;
this.btnProcesar.Enabled = true;
this.btnGuardar.Enabled = true;
this.btnPausar.Enabled = false;
//this.pnlGuardado.Visible = false;
foreach (DataGridViewColumn oCol in this.dgvDatos.Columns)
{
oCol.SortMode = DataGridViewColumnSortMode.Automatic;
}
UtilLocal.MostrarNotificacion("Proceso completado correctamente.");
}
#endregion
}
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 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 el cliente
if (this.oControlVentas.Cliente == null)
{
UtilLocal.MensajeAdvertencia("No hay ningún cliente seleccionado o cliente inválido.");
return(false);
}
// Se validan los productos
if (!this.oControlVentas.Validar())
{
return(false);
}
// Se validan si hay una parte de cobro de diferencia de casco, sea la única en la venta
var oVentaDet = this.oControlVentas.GenerarVentaDetalle();
foreach (var oReg in oVentaDet)
{
if (Datos.Exists <Parte>(c => c.ParteID == oReg.ParteID && c.EsCascoPara > 0) || oReg.ParteID == Cat.Partes.DiferenciaDeCascos)
{
if (oVentaDet.Count > 1)
{
UtilLocal.MensajeAdvertencia("La venta contiene un artículo Casco, por lo cual no puede contener otros artículos.");
return(false);
}
}
}
// Se verifica si se debe mostrar la opción de cobro
if (!this.oControlVentas.CobroAlFrente)
{
if (this.oControlVentas.ctlCobro == null)
{
this.oControlVentas.ctlCobro = new Cobro()
{
Dock = DockStyle.Fill
};
this.oControlVentas.pnlContenidoDetalle.Controls.Add(this.oControlVentas.ctlCobro);
// Se configura el evento Click para el botón de cotización
this.oControlVentas.ctlCobro.Cotizacion_Click += new EventHandler((s, e) =>
{
this.GenerarCotizacion();
});
}
this.oControlVentas.ctlCobro.CambiarCliente(this.oControlVentas.Cliente.ClienteID);
this.oControlVentas.ctlCobro.Total = this.oControlVentas.Total;
// Sólo se permite cambiar el vendedor, no cobrar
this.oControlVentas.ctlCobro.HabilitarTipoDePago = false;
this.oControlVentas.ctlCobro.MostrarFacturar = false;
this.oControlVentas.ctlCobro.MostrarFacturarDividir = false;
this.oControlVentas.ctlCobro.HabilitarCotizacion = true;
this.oControlVentas.ctlCobro.HabilitarFormasDePago = false;
this.oControlVentas.ctlCobro.Total = 0;
this.oControlVentas.ctlCobro.BringToFront();
return(false);
}
// Se verifica si es cotización
if (this.oControlVentas.EsCotizacion)
{
UtilLocal.MensajeAdvertencia("No se puede realizar la venta porque esta es sólo una cotización.");
return(false);
}
// Se intenta completar
if (!this.oControlVentas.ctlCobro.CompletarCobro())
{
return(false);
}
//decimal mImportePato = Util.Decimal(Config.Valor("Ventas.ImportePato"));
//bool esPato = false;
//if (this.oControlVentas.Total >= mImportePato)
//{
// var hunt = new Duck(UtilLocal.RutaRecursos() + "huntduck2.wmv");
// hunt.Show(Principal.Instance);
// esPato = true;
//} else // Se muestra la ventana de "Cargando.."
Cargando.Mostrar();
// Se procede a guardar la venta
DateTime dAhora = DateTime.Now;
// Se crea el objeto de la nueva venta
Venta oVenta = new Venta()
{
Fecha = dAhora,
ClienteID = this.oControlVentas.Cliente.ClienteID,
VentaEstatusID = Cat.VentasEstatus.Realizada,
RealizoUsuarioID = this.oControlVentas.ctlCobro.VendodorID,
RepartidorID = (this.oControlVentas.ctlCobro.RepartidorID > 0 ? (int?)this.oControlVentas.ctlCobro.RepartidorID : null),
ComisionistaClienteID = this.oControlVentas.ctlCobro.ComisionistaID,
ClienteVehiculoID = this.oControlVentas.ctlCobro.ClienteVehiculoID,
Kilometraje = this.oControlVentas.ctlCobro.Kilometraje
};
// Se manda a guardar la venta
var oVentaDetalle = this.oControlVentas.GenerarVentaDetalle();
Guardar.Venta(oVenta, oVentaDetalle);
// Se agrega al Kardex
// ** Se hace al momento de cobrar :\
// Se generan los datos de pago (no en la primer versión)
/* var oPago = this.ctlCobro.GenerarPago();
* oPago.VentaID = oVenta.VentaID;
* oPago.Fecha = dAhora;
* var oPagoDetalle = this.ctlCobro.GenerarPagoDetalle();
* // Se mandan guardar los datos del pago
* Guardar.VentaPago(oPago, oPagoDetalle);
*/
// Se imprimen los tickets correspondientes
// .. aquí no hay tickets, sino hasta que se paga, creo
// Se guarda la leyenda, para usarla en el ticket, después de cobrar
if (this.oControlVentas.ctlCobro.Leyenda != "")
{
VentasProc.AgregarLeyenda(oVenta.VentaID, this.oControlVentas.ctlCobro.Leyenda);
}
// Se hace verificación para control de cascos
foreach (var oReg in oVentaDetalle)
{
if (Datos.Exists <Parte>(c => c.ParteID == oReg.ParteID && c.RequiereCascoDe > 0 && c.Estatus))
{
// Se agrega el registro para casco, uno por cada casco según la cantidad
for (int i = 0; i < oReg.Cantidad; i++)
{
var oCascoReg = new CascoRegistro()
{
Fecha = dAhora,
VentaID = oVenta.VentaID,
ParteID = oReg.ParteID
};
Datos.Guardar <CascoRegistro>(oCascoReg);
}
}
}
// Se guardan los datos de la aplicación, si hubiera
if (this.oControlVentas.oAplicaciones != null && this.oControlVentas.oAplicaciones.Count > 0)
{
foreach (var oReg in this.oControlVentas.oAplicaciones)
{
var oRegVentaD = oVentaDetalle.FirstOrDefault(c => c.ParteID == oReg.ParteID);
oReg.VentaID = oVenta.VentaID;
oReg.Cantidad = oRegVentaD.Cantidad;
Datos.Guardar <VentaParteAplicacion>(oReg);
}
}
// Se cierra la ventana de "Cargando.."
//if(!esPato)
Cargando.Cerrar();
// Se muestra notificación y se limpia el formulario
UtilLocal.MostrarNotificacion("La Venta ha sido guardada 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);
}
private bool Agregar9500()
{
// Se valida la parte de "Partes"
if (!this.ctlPartes.Validar())
{
return(false);
}
// Se pide el efectivo, si aplica
if (!this.ctlCobro.CompletarCobro())
{
return(false);
}
// Se valida que exista una Medida genérica, para las nuevas partes
if (Datos.GetEntity <Medida>(q => q.MedidaID == Cat.Medidas.Pieza && q.Estatus) == null)
{
UtilLocal.MensajeAdvertencia("No existe una Medida genérica para asignarle a las partes nuevas. No se puede continuar.");
return(false);
}
// Se solicitan la autorizaciones, si se requiere
int iAutorizoID = 0;
if (this.ctlPartes.AutorizacionRequeridaPrecio || this.ctlPartes.AutorizacionRequeridaAnticipo)
{
string sPermiso = (this.ctlPartes.AutorizacionRequeridaPrecio ? "Autorizaciones.Ventas.9500.PrecioFueraDeRango" :
"Autorizaciones.Ventas.9500.NoAnticipo");
var Res = UtilLocal.ValidarObtenerUsuario(sPermiso, "Autorización");
iAutorizoID = (Res.Respuesta == null ? 0 : Res.Respuesta.UsuarioID);
}
// Se procede a guardar los datos
DateTime dAhora = DateTime.Now;
// Se genera la Cotización 9500
var o9500 = this.ctlPartes.Generar9500();
o9500.Fecha = dAhora;
o9500.RealizoUsuarioID = this.ctlCobro.VendodorID;
if (this.ctlCobro.ComisionistaID > 0)
{
o9500.ComisionistaClienteID = this.ctlCobro.ComisionistaID;
}
// Se genera el detalle del 9500
var oParteGanancia = this.ctlPartes.ObtenerParteGanancia(null);
var o9500Detalle = new List <Cotizacion9500Detalle>();
foreach (var Parte9500 in this.ctlPartes.Detalle)
{
// Si la parte no existe, se agrega
if (Parte9500.Value.ParteID <= 0)
{
int iFila = UtilLocal.findRowIndex(this.ctlPartes.dgvPartes, "Llave", Parte9500.Key);
string sNumeroDeParte = Util.Cadena(this.ctlPartes.dgvPartes["NumeroDeParte", iFila].Value);
string sDescripcion = Util.Cadena(this.ctlPartes.dgvPartes["Descripcion", iFila].Value);
var oLinea = Datos.GetEntity <Linea>(q => q.LineaID == Parte9500.Value.LineaID && q.Estatus);
Parte oParte = new Parte()
{
NumeroParte = sNumeroDeParte,
LineaID = Parte9500.Value.LineaID,
MarcaParteID = Parte9500.Value.MarcaParteID,
ProveedorID = Parte9500.Value.ProveedorID,
NombreParte = sDescripcion,
Es9500 = true,
SubsistemaID = oLinea.SubsistemaID.Valor()
};
// Se agregan los precios
PartePrecio oPartePrecio = null;
if (oParteGanancia != null)
{
oPartePrecio = new PartePrecio()
{
Costo = Parte9500.Value.Costo,
PorcentajeUtilidadUno = oParteGanancia.PorcentajeDeGanancia1,
PorcentajeUtilidadDos = oParteGanancia.PorcentajeDeGanancia2,
PorcentajeUtilidadTres = oParteGanancia.PorcentajeDeGanancia3,
PorcentajeUtilidadCuatro = oParteGanancia.PorcentajeDeGanancia4,
PorcentajeUtilidadCinco = oParteGanancia.PorcentajeDeGanancia5,
PrecioUno = UtilTheos.AplicarRedondeo(Parte9500.Value.Costo * oParteGanancia.PorcentajeDeGanancia1),
PrecioDos = UtilTheos.AplicarRedondeo(Parte9500.Value.Costo * oParteGanancia.PorcentajeDeGanancia2),
PrecioTres = UtilTheos.AplicarRedondeo(Parte9500.Value.Costo * oParteGanancia.PorcentajeDeGanancia3),
PrecioCuatro = UtilTheos.AplicarRedondeo(Parte9500.Value.Costo * oParteGanancia.PorcentajeDeGanancia4),
PrecioCinco = UtilTheos.AplicarRedondeo(Parte9500.Value.Costo * oParteGanancia.PorcentajeDeGanancia5)
};
}
// Se guarda
Guardar.Parte(oParte, oPartePrecio);
Parte9500.Value.ParteID = oParte.ParteID;
}
// Se agrega la parte al detalle del 9500
o9500Detalle.Add(Parte9500.Value);
}
// Se guardan los datos de 9500
Guardar.c9500(o9500, o9500Detalle);
// Se genera la venta con el anticipo
var oVenta = new Venta()
{
ClienteID = o9500.ClienteID,
RealizoUsuarioID = o9500.RealizoUsuarioID
};
var oPrecioAnticipo = Datos.GetEntity <PartePrecio>(c => c.ParteID == Cat.Partes.AnticipoClientes && c.Estatus);
var oVentaDetalle = new VentaDetalle()
{
ParteID = Cat.Partes.AnticipoClientes,
Cantidad = 1,
PrecioUnitario = o9500.Anticipo,
Costo = oPrecioAnticipo.Costo.Valor(),
CostoConDescuento = (oPrecioAnticipo.CostoConDescuento ?? oPrecioAnticipo.Costo.Valor())
};
Guardar.Venta(oVenta, new List <VentaDetalle>()
{
oVentaDetalle
});
// Se guarda el dato de la venta con el anticipo en el registro de 9500
o9500.AnticipoVentaID = oVenta.VentaID;
Datos.Guardar <Cotizacion9500>(o9500);
// Se guardan las autorizaciones, si hubiera
if (this.ctlPartes.AutorizacionRequeridaPrecio)
{
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.c9500PrecioFueraDeRango, Cat.Tablas.Tabla9500, o9500.Cotizacion9500ID, iAutorizoID);
}
if (this.ctlPartes.AutorizacionRequeridaAnticipo)
{
VentasProc.GenerarAutorizacion(Cat.AutorizacionesProcesos.c9500SinAnticipo, Cat.Tablas.Tabla9500, o9500.Cotizacion9500ID, iAutorizoID);
}
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion("Cotización 9500 guardada correctamente.");
return(true);
}
private bool Completar9500()
{
// Se validan las partes
if (!this.ctlComDetalle.Validar())
{
return(false);
}
//if (Util.ControlAlFrente(this.pnlCompletar) == this.ctlComDetalle)
//{
//}
// Se verifica que se haya hecho el pago del anticipo
Cotizacion9500 o9500 = this.ctlPartes.oCotizacion9500;
if (!Datos.Exists <Venta>(c => c.VentaID == o9500.AnticipoVentaID &&
(c.VentaEstatusID == Cat.VentasEstatus.Completada || c.VentaEstatusID == Cat.VentasEstatus.Cobrada)))
{
UtilLocal.MensajeAdvertencia("Al parecer no se ha realizado el pago correspondiente al Anticipo. No se puede continuar.");
return(false);
}
// Se confirma la operación
if (UtilLocal.MensajePregunta(string.Format("¿Estás seguro que deseas completar el 9500 con el folio {0}?\n\n{1}"
, this.ctlPartes.oCotizacion9500.Cotizacion9500ID, this.ctlPartes.o9500Sel["lisDescripcion"])) != DialogResult.Yes)
{
return(false);
}
// Se guardan los datos
DateTime dAhora = DateTime.Now;
// Se cancela la venta del anticipo
/* Ya no. Ahora todo esto se hace al cobrar la venta final
* oVenta.VentaEstatusID = Cat.VentasEstatus.Cancelada;
* Datos.Guardar<Venta>(oVenta);
* // 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 (oVentaPago != null)
* VentasProc.GenerarDevolucionDeEfectivo(o9500.AnticipoVentaID.Valor(), o9500.Anticipo);
*/
// Se genera la venta correspondiente al 9500
// var o9500Detalle = General.GetListOf<Cotizacion9500Detalle>(q => q.Estatus && q.Cotizacion9500ID == oCotizacion9500.Cotizacion9500ID);
var oCliente = Datos.GetEntity <Cliente>(q => q.ClienteID == o9500.ClienteID && q.Estatus);
var oDetalle = this.ctlComDetalle.ProductosSel();
var oVenta = new Venta()
{
Fecha = dAhora,
ClienteID = o9500.ClienteID,
VentaEstatusID = Cat.VentasEstatus.Realizada,
RealizoUsuarioID = o9500.RealizoUsuarioID,
ComisionistaClienteID = o9500.ComisionistaClienteID
};
var oVentaDetalle = new List <VentaDetalle>();
foreach (var oParte in oDetalle)
{
// Se toma el precio de la tabla "PartePrecio", pues pudo haber sido cambiado por el encargado de Compras
var oPartePrecio = Datos.GetEntity <PartePrecio>(q => q.ParteID == oParte.ParteID);
decimal mPrecio = UtilDatos.PartePrecioDeVenta(oPartePrecio, oCliente.ListaDePrecios);
// Se agrega la parte al detalle de la venta
oVentaDetalle.Add(new VentaDetalle()
{
ParteID = oParte.ParteID,
Costo = oPartePrecio.Costo.Valor(),
CostoConDescuento = (oPartePrecio.CostoConDescuento ?? oPartePrecio.Costo.Valor()),
Cantidad = oParte.Cantidad,
PrecioUnitario = UtilTheos.ObtenerPrecioSinIva(mPrecio, 3),
Iva = UtilTheos.ObtenerIvaDePrecio(mPrecio, 3)
});
}
// Se guarda la venta
Guardar.Venta(oVenta, oVentaDetalle);
// Se modifica el dato de la venta correspondiente al 9500
o9500.VentaID = oVenta.VentaID;
o9500.EstatusGenericoID = Cat.EstatusGenericos.PorCompletar;
Datos.Guardar <Cotizacion9500>(o9500);
// Se restaura
this.ctlPartes.ComCliente = null;
this.pnlEnTotales.Controls.Remove(this.pnlCompletar);
this.pnlCompletar.Dispose();
this.pnlCompletar = null;
this.CambiarOpcion(eOpcion.Agregar);
this.ctlPartes.tab9500.SelectedIndex = 0;
// Se muestra una notifiación con el resultado
UtilLocal.MostrarNotificacion("Cotización 9500 guardada correctamente.");
// Se retorna falso para que no se quite la opción de 9500
return(false);
}
private void GuardarDatos()
{
// Se solicita la autorización
var oResU = UtilLocal.ValidarObtenerUsuario("Administracion.Master.Modificar");
if (oResU.Error)
{
return;
}
int iUsuarioID = oResU.Respuesta.UsuarioID;
// Se muestra progreso de avance
this.IniciarTerminarProgreso(true);
// Se inicia el proceso de guardado
Datos.StartPersistentContext();
int iErroresVal = 0;
var oCambios = new List <ParteCambio>();
var oVarCostos = new Dictionary <int, decimal>();
foreach (DataGridViewRow Fila in this.dgvDatos.Rows)
{
this.pgrGuardar.EjecutarPaso(true);
if (!Fila.Visible)
{
continue;
}
if (!Util.Logico(Fila.Cells["Procesar"].Value))
{
continue;
}
int iParteID = Util.Entero(Fila.Cells["ParteID"].Value);
bool bCambioParte = (Util.Entero(Fila.Cells["CambioParte"].Value) == Cat.TiposDeAfectacion.Modificar);
bool bCambioPrecio = (Util.Entero(Fila.Cells["CambioPrecio"].Value) == Cat.TiposDeAfectacion.Modificar);
// Se valida el Proveedor - Marca - Línea
int iProveedorID = 0, iMarcaID = 0, iLineaID = 0;
if (bCambioParte || bCambioPrecio)
{
iProveedorID = Util.Entero(Fila.Cells["ProveedorID"].Value);
iMarcaID = Util.Entero(Fila.Cells["MarcaID"].Value);
iLineaID = Util.Entero(Fila.Cells["LineaID"].Value);
if (!Datos.Exists <ProveedorMarcaParte>(q => q.ProveedorID == iProveedorID && q.MarcaParteID == iMarcaID && q.Estatus) ||
!Datos.Exists <LineaMarcaParte>(q => q.MarcaParteID == iMarcaID && q.LineaID == iLineaID && q.Estatus))
{
Fila.ErrorText = "Proveedor - Marca - Línea inválido.";
// Fila.DefaultCellStyle.ForeColor = Color.Red;
iErroresVal++;
continue;
}
}
// Se guardan los datos de la parte, si aplica
if (bCambioParte)
{
var oParte = Datos.GetEntity <Parte>(q => q.ParteID == iParteID && q.Estatus);
string sNumeroDeParte = Util.Cadena(Fila.Cells["NumeroDeParte"].Value);
string sDescripcion = Util.Cadena(Fila.Cells["Descripcion"].Value);
int iUnidadDeMedidaID = Util.Entero(Fila.Cells["UnidadDeMedidaID"].Value);
decimal mUnidadDeEmpaque = Util.Decimal(Fila.Cells["UnidadDeEmpaque"].Value);
decimal mTiempoDeReposicion = Util.Decimal(Fila.Cells["TiempoDeReposicion"].Value);
bool bComision = Util.Logico(Fila.Cells["Comision"].Value);
bool bServicio = Util.Logico(Fila.Cells["Servicio"].Value);
bool bEtiqueta = Util.Logico(Fila.Cells["Etiqueta"].Value);
bool bSoloUna = Util.Logico(Fila.Cells["SoloUna"].Value);
bool bEsPar = Util.Logico(Fila.Cells["EsPar"].Value);
string sCodigoDeBarras = Util.Cadena(Fila.Cells["CodigoDeBarra"].Value);
// Para agregar registro de cambios
if (Util.Cadena(oParte.NumeroParte) != sNumeroDeParte)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.NumeroDeParte, oParte.NumeroParte, sNumeroDeParte);
oParte.NumeroParte = sNumeroDeParte;
}
if (Util.Cadena(oParte.NombreParte) != sDescripcion)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Descripcion, oParte.NombreParte, sDescripcion);
oParte.NombreParte = sDescripcion;
}
if (oParte.ProveedorID != iProveedorID)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Proveedor, oParte.ProveedorID.ToString(), iProveedorID.ToString());
oParte.ProveedorID = iProveedorID;
}
if (oParte.LineaID != iLineaID)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Linea, oParte.LineaID.ToString(), iLineaID.ToString());
oParte.LineaID = iLineaID;
}
if (oParte.MarcaParteID != iMarcaID)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Marca, oParte.MarcaParteID.ToString(), iMarcaID.ToString());
oParte.MarcaParteID = iMarcaID;
}
if (oParte.MedidaID.Valor() != iUnidadDeMedidaID)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.UnidadDeMedida, oParte.MedidaID.ToString(), iUnidadDeMedidaID.ToString());
oParte.MedidaID = iUnidadDeMedidaID;
}
if (oParte.UnidadEmpaque != mUnidadDeEmpaque)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.UnidadDeEmpaque, oParte.UnidadEmpaque.ToString(), mUnidadDeEmpaque.ToString());
oParte.UnidadEmpaque = mUnidadDeEmpaque;
}
if (oParte.TiempoReposicion != mTiempoDeReposicion)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.TiempoDeReposicion, oParte.TiempoReposicion.ToString(), mTiempoDeReposicion.ToString());
oParte.TiempoReposicion = mTiempoDeReposicion;
}
if (oParte.AplicaComision.Valor() != bComision)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.AplicaComision, this.CadenaDeBool(oParte.AplicaComision), bComision.ACadena());
oParte.AplicaComision = bComision;
}
if (oParte.EsServicio.Valor() != bServicio)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.EsServicio, this.CadenaDeBool(oParte.EsServicio), bServicio.ACadena());
oParte.EsServicio = bServicio;
}
if (oParte.Etiqueta.Valor() != bEtiqueta)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Etiqueta, this.CadenaDeBool(oParte.Etiqueta), bEtiqueta.ACadena());
oParte.Etiqueta = bEtiqueta;
}
if (oParte.SoloUnaEtiqueta.Valor() != bSoloUna)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.SoloUnaEtiqueta, this.CadenaDeBool(oParte.SoloUnaEtiqueta), bSoloUna.ACadena());
oParte.SoloUnaEtiqueta = bSoloUna;
}
if (oParte.EsPar.Valor() != bEsPar)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.EsPar, this.CadenaDeBool(oParte.EsPar), bEsPar.ACadena());
oParte.EsPar = bEsPar;
}
if (Util.Cadena(oParte.CodigoBarra) != sCodigoDeBarras)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.CodigoDeBarras, oParte.CodigoBarra, sCodigoDeBarras);
oParte.CodigoBarra = sCodigoDeBarras;
}
/* oParte.NumeroParte = Util.ConvertirCadena(Fila.Cells["NumeroDeParte"].Value);
* oParte.NombreParte = Util.ConvertirCadena(Fila.Cells["Descripcion"].Value);
* oParte.ProveedorID = Util.ConvertirEntero(Fila.Cells["ProveedorID"].Value);
* oParte.LineaID = Util.ConvertirEntero(Fila.Cells["LineaID"].Value);
* oParte.MarcaParteID = Util.ConvertirEntero(Fila.Cells["MarcaID"].Value);
* oParte.MedidaID = Util.ConvertirEntero(Fila.Cells["UnidadDeMedidaID"].Value);
* oParte.AplicaComision = Util.ConvertirBool(Fila.Cells["Comision"].Value);
* oParte.EsServicio = Util.ConvertirBool(Fila.Cells["Servicio"].Value);
* oParte.Etiqueta = Util.ConvertirBool(Fila.Cells["Etiqueta"].Value);
* oParte.SoloUnaEtiqueta = Util.ConvertirBool(Fila.Cells["SoloUna"].Value);
* oParte.CodigoBarra = Util.ConvertirCadena(Fila.Cells["CodigoDeBarra"].Value);
*/
Datos.Guardar <Parte>(oParte);
}
// Se guardan los datos de precios
if (bCambioPrecio)
{
var oParte = Datos.GetEntity <PartePrecio>(q => q.ParteID == iParteID && q.Estatus);
decimal mCosto = Util.Decimal(Fila.Cells["Costo"].Value);
decimal mCostoConDescuento = Util.Decimal(Fila.Cells["CostoConDescuento"].Value);
decimal mPorUtil1 = Util.Decimal(Fila.Cells["Por1"].Value);
decimal mPorUtil2 = Util.Decimal(Fila.Cells["Por2"].Value);
decimal mPorUtil3 = Util.Decimal(Fila.Cells["Por3"].Value);
decimal mPorUtil4 = Util.Decimal(Fila.Cells["Por4"].Value);
decimal mPorUtil5 = Util.Decimal(Fila.Cells["Por5"].Value);
decimal mPrecio1 = Util.Decimal(Fila.Cells["Precio1"].Value);
decimal mPrecio2 = Util.Decimal(Fila.Cells["Precio2"].Value);
decimal mPrecio3 = Util.Decimal(Fila.Cells["Precio3"].Value);
decimal mPrecio4 = Util.Decimal(Fila.Cells["Precio4"].Value);
decimal mPrecio5 = Util.Decimal(Fila.Cells["Precio5"].Value);
// Para agregar registro de cambios
if (oParte.Costo.Valor() != mCosto)
{
// Para calcular la diferencia total en costo, por sucursal
decimal mVarCosto = (mCosto - oParte.Costo.Valor());
var oExistencias = Datos.GetListOf <ParteExistencia>(c => c.ParteID == iParteID && c.Estatus);
foreach (var oReg in oExistencias)
{
if (!oVarCostos.ContainsKey(oReg.SucursalID))
{
oVarCostos.Add(oReg.SucursalID, 0);
}
oVarCostos[oReg.SucursalID] += (mVarCosto * oReg.Existencia.Valor());
}
//
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Costo, this.CadenaDeDecimal(oParte.Costo), mCosto.ToString());
oParte.Costo = mCosto;
}
if (oParte.CostoConDescuento.Valor() != mCostoConDescuento)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.CostoConDescuento
, this.CadenaDeDecimal(oParte.CostoConDescuento), mCostoConDescuento.ToString());
oParte.CostoConDescuento = mCostoConDescuento;
}
if (oParte.PorcentajeUtilidadUno.Valor() != mPorUtil1)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.PorUtil1, this.CadenaDeDecimal(oParte.PorcentajeUtilidadUno), mPorUtil1.ToString());
oParte.PorcentajeUtilidadUno = mPorUtil1;
}
if (oParte.PorcentajeUtilidadDos.Valor() != mPorUtil2)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.PorUtil2, this.CadenaDeDecimal(oParte.PorcentajeUtilidadDos), mPorUtil2.ToString());
oParte.PorcentajeUtilidadDos = mPorUtil2;
}
if (oParte.PorcentajeUtilidadTres.Valor() != mPorUtil3)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.PorUtil3, this.CadenaDeDecimal(oParte.PorcentajeUtilidadTres), mPorUtil3.ToString());
oParte.PorcentajeUtilidadTres = mPorUtil3;
}
if (oParte.PorcentajeUtilidadCuatro.Valor() != mPorUtil4)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.PorUtil4, this.CadenaDeDecimal(oParte.PorcentajeUtilidadCuatro), mPorUtil4.ToString());
oParte.PorcentajeUtilidadCuatro = mPorUtil4;
}
if (oParte.PorcentajeUtilidadCinco.Valor() != mPorUtil5)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.PorUtil5, this.CadenaDeDecimal(oParte.PorcentajeUtilidadCinco), mPorUtil5.ToString());
oParte.PorcentajeUtilidadCinco = mPorUtil5;
}
if (oParte.PrecioUno.Valor() != mPrecio1)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Precio1, this.CadenaDeDecimal(oParte.PrecioUno), mPrecio1.ToString());
oParte.PrecioUno = mPrecio1;
}
if (oParte.PrecioDos.Valor() != mPrecio2)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Precio2, this.CadenaDeDecimal(oParte.PrecioDos), mPrecio2.ToString());
oParte.PrecioDos = mPrecio2;
}
if (oParte.PrecioTres.Valor() != mPrecio3)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Precio3, this.CadenaDeDecimal(oParte.PrecioTres), mPrecio3.ToString());
oParte.PrecioTres = mPrecio3;
}
if (oParte.PrecioCuatro.Valor() != mPrecio4)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Precio4, this.CadenaDeDecimal(oParte.PrecioCuatro), mPrecio4.ToString());
oParte.PrecioCuatro = mPrecio4;
}
if (oParte.PrecioCinco.Valor() != mPrecio5)
{
this.AgregarCambio(oCambios, oParte.ParteID, Cat.PartesCambios.Precio5, this.CadenaDeDecimal(oParte.PrecioCinco), mPrecio5.ToString());
oParte.PrecioCinco = mPrecio5;
}
/* oParte.Costo = Util.ConvertirDecimal(Fila.Cells["Costo"].Value);
* oParte.PorcentajeUtilidadUno = Util.ConvertirDecimal(Fila.Cells["Por1"].Value);
* oParte.PrecioUno = Util.ConvertirDecimal(Fila.Cells["Precio1"].Value);
* oParte.PorcentajeUtilidadDos = Util.ConvertirDecimal(Fila.Cells["Por2"].Value);
* oParte.PrecioDos = Util.ConvertirDecimal(Fila.Cells["Precio2"].Value);
* oParte.PorcentajeUtilidadTres = Util.ConvertirDecimal(Fila.Cells["Por3"].Value);
* oParte.PrecioTres = Util.ConvertirDecimal(Fila.Cells["Precio3"].Value);
* oParte.PorcentajeUtilidadCuatro = Util.ConvertirDecimal(Fila.Cells["Por4"].Value);
* oParte.PrecioCuatro = Util.ConvertirDecimal(Fila.Cells["Precio4"].Value);
* oParte.PorcentajeUtilidadCinco = Util.ConvertirDecimal(Fila.Cells["Por5"].Value);
* oParte.PrecioCinco = Util.ConvertirDecimal(Fila.Cells["Precio5"].Value);
*/
Datos.Guardar <PartePrecio>(oParte);
}
// Se restaura la fila
if (bCambioParte || bCambioPrecio)
{
Fila.Cells["CambioParte"].Value = Cat.TiposDeAfectacion.SinCambios;
Fila.Cells["CambioPrecio"].Value = Cat.TiposDeAfectacion.SinCambios;
Fila.ErrorText = "";
// Fila.DefaultCellStyle.ForeColor = Color.Black;
}
}
// Se generan los pólizas correspondientes por diferencias de costos
string sObsPoliza = Util.Cadena(this.dgvDatos.Columns["Costo"].Tag);
foreach (var oDif in oVarCostos)
{
if (oDif.Value != 0)
{
ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Diario, sObsPoliza, Cat.ContaCuentasAuxiliares.Inventario, Cat.ContaCuentasAuxiliares.CapitalFijo
, oDif.Value, "", null, null, oDif.Key);
}
}
// Se guardan los cambios
UtilLocal.MostrarNotificacion("Guardando registro de cambios...");
Application.DoEvents();
this.pgrGuardar.Inicializar(oCambios.Count, 1);
DateTime dAhora = DateTime.Now;
foreach (var oCambio in oCambios)
{
oCambio.Fecha = dAhora;
oCambio.UsuarioID = iUsuarioID;
Datos.Guardar <ParteCambio>(oCambio, false);
this.pgrGuardar.EjecutarPaso(true);
}
Datos.EndPersistentContext();
// Se restaura el color de las celdas, si no hubo error
foreach (DataGridViewRow Fila in this.dgvDatos.Rows)
{
if (Fila.ErrorText == "")
{
foreach (DataGridViewCell Celda in Fila.Cells)
{
if (Celda.HasStyle)
{
Celda.Style.ForeColor = Color.Black;
}
}
}
}
this.IniciarTerminarProgreso(false);
UtilLocal.MostrarNotificacion("Proceso completado " + (iErroresVal > 0 ? "con errores." : "correctamente."));
}
private bool AccionGuardar()
{
if (!this.Validar())
{
return(false);
}
// Se borran los "devengados", si hay
foreach (int iDevBorrarID in this.EgresosDevBorrados)
{
ContaProc.DevengadoEliminar(iDevBorrarID);
}
// Se borran los especials, si hay
foreach (int iDevID in this.DevEspecialBorrados)
{
ContaProc.DevengadoEspecialEliminar(iDevID);
}
// Se procesan los nuevos
foreach (DataGridViewRow oFila in this.dgvDetalle.Rows)
{
if (oFila.Cells["RegistroID"].Value != null)
{
continue;
}
// Se genera el "devengado", según corresponda
if (((TipoDev)oFila.Cells["colTipoDev"].Value) == TipoDev.Sucursal)
{
var oEgresoDev = new ContaEgresoDevengado()
{
ContaEgresoID = this.oEgreso.ContaEgresoID,
Fecha = Util.FechaHora(oFila.Cells["Fecha"].Value),
Importe = Util.Decimal(oFila.Cells["Importe"].Value),
SucursalID = Util.Entero(oFila.Cells["SelID"].Value),
};
// Se obtiene el detalle, si aplica
var oDetalleDev = (oFila.Tag as List <ContaEgresoDetalleDevengado>);
// Se manda guardar los datos
ContaProc.GastoDevengar(oEgresoDev, oDetalleDev);
}
else
{
var oDevEsp = new ContaEgresoDevengadoEspecial()
{
ContaEgresoID = this.oEgreso.ContaEgresoID,
Fecha = Util.FechaHora(oFila.Cells["Fecha"].Value),
DuenioID = Util.Entero(oFila.Cells["SelID"].Value),
Importe = Util.Decimal(oFila.Cells["Importe"].Value)
};
// Datos.Guardar<ContaEgresoDevengadoEspecial>(oDevEsp);
// Se obtiene el detalle, si aplica
var oDetalleDev = (oFila.Tag as List <ContaEgresoDetalleDevengadoEspecial>);
// Se manda guardar los datos
ContaProc.GastoDevengarEspecial(oDevEsp, oDetalleDev);
}
}
// Se muestra una notificación
UtilLocal.MostrarNotificacion("Proceso completado correctamente.");
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);
}
