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);
}
bool bExito;
if (this.Opcion == eOpcion.Agregar)
{
bExito = this.Agregar9500();
}
else
{
bExito = this.Completar9500();
}
if (!bExito)
{
return(false);
}
// Se limpia después de haberse guardado
this.Limpiar();
return(true);
}
private void LlenarColumnasAnio(int iAnio)
{
// Se borran las columnas de semanas
for (int iCol = (this.tgvDatos.Columns.Count - 1); iCol > 1; iCol--)
{
this.tgvDatos.Columns.RemoveAt(iCol);
}
// Se agregan las nuevas columnas
DateTime dDia = new DateTime(iAnio, DateTime.Now.Month, DateTime.Now.Day);
var oFechas = UtilDatos.FechasDeComisiones(new DateTime(iAnio, 1, 1));
DateTime dIni = oFechas.Valor1;
int iColSem = 0;
while (dIni.Year <= iAnio)
{
string sEnc = string.Format("{0}\n{1}", dIni.ToString("dd/MMM"), dIni.AddDays(6).ToString("dd/MMM"));
var oCol = new DataGridViewTextBoxColumn()
{
Name = ("Sem" + dIni.ToString("d")), HeaderText = sEnc, Width = 80
};
oCol.FormatoMoneda();
this.tgvDatos.Columns.Add(oCol);
if (dDia >= dIni && dDia < dIni.AddDays(7))
{
iColSem = this.tgvDatos.Columns.Count;
}
dIni = dIni.AddDays(7);
}
// this.tgvDatos.HorizontalScrollingOffset = this.tgvDatos.Columns[10].HeaderCell.ContentBounds.Left;
this.tgvDatos.FirstDisplayedScrollingColumnIndex = (iColSem - 1);
}
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 CuadroMetas_Load(object sender, EventArgs e)
{
//CuadroControlPermisos PermisosC = new CuadroControlPermisos();
// Se llenan los controles iniciales
//var oSucursales = Datos.GetListOf<Sucursal>(c => c.Estatus);
var oSucursales = CuadroControlPermisos.ValidarPermisosTiendaCuadroMultiple(CuadroControlPermisos.GetTabPage);
if (oSucursales.Count > 2)
{
//oSucursales.Insert(0, new Sucursal() { SucursalID = 0, NombreSucursal = "Todas" });
oSucursales.Insert(0, new Sucursal()
{
NombreSucursal = "(TODAS)"
});
}
//oSucursales.Insert(0, new Sucursal() { NombreSucursal = "(TODAS)" });
this.cmbSucursal.CargarDatos("SucursalID", "NombreSucursal", oSucursales);
// this.cmbSucursal.SelectedValue = GlobalClass.SucursalID;
var oFechas = UtilDatos.FechasDeComisiones(DateTime.Now);
this.dtpDesde.Value = oFechas.Valor1;
this.dtpHasta.Value = oFechas.Valor2;
this.cmbVendedor.CargarDatos("UsuarioID", "NombreUsuario", Datos.GetListOf <Usuario>(c => c.Estatus));
}
public static ResAcc InicializarAplicacion()
{
// Se llena la cadena de conexión
string sCadenaDeConexion = System.Configuration.ConfigurationManager.ConnectionStrings[GlobalClass.Modo].ConnectionString;
string sUsuario = sCadenaDeConexion.Extraer("user id=", ";");
string sContrasenia = sCadenaDeConexion.Extraer("password="******";");
if (sUsuario.Length > 0)
{
sCadenaDeConexion = sCadenaDeConexion.Replace(sUsuario, UtilLocal.Desencriptar(sUsuario));
}
if (sContrasenia.Length > 0)
{
sCadenaDeConexion = sCadenaDeConexion.Replace(sContrasenia, UtilLocal.Desencriptar(sContrasenia));
}
Datos.CadenaDeConexion = sCadenaDeConexion;
// Se cargan parámetros de configuración iniciales
var oResCon = Proc.loadConfiguraciones();
if (oResCon.Error)
{
return(oResCon);
}
// Se verifica la hora del sistema con la hora de sql
if (Math.Abs((DateTime.Now - UtilDatos.FechaServidorDeDatos()).Minutes) >= 5)
{
return(new ResAcc(false, "Favor de actualizar la fecha y hora de la computadora. Informar a Soporte Técnico."));
}
return(new ResAcc(true));
}
public static void VerInventarioConteoPendiente(object o)
{
// Se comprueba si hay conteos pendientes en la sucursal, cuando aplique
string sMensaje = "";
var oConteosPen = UtilDatos.InventarioUsuariosConteoPendiente();
foreach (string sUsuario in oConteosPen)
{
sMensaje += string.Format("El usuario {0} no ha concluido su conteo.\n", sUsuario);
}
if (sMensaje != "")
{
Principal.Instance.MostrarMensaje(new DosVal <string, string>("Recordatorio de Invenario", sMensaje));
}
}
public void ActualizarListado()
{
configurarAsistencias();
var fechaActual = UtilDatos.FechasDeComisiones(DateTime.Now);
dtpFechaDesde.Value = fechaActual.Valor1;
dtpFechaHasta.Value = fechaActual.Valor2;
var oAsistencias = Datos.GetListOf <UsuariosAsistenciasView>(u => u.FechaHora >= fechaActual.Valor1 && u.FechaHora <= fechaActual.Valor2).OrderBy(u => u.AccesoUsuarioID);
foreach (var asistencia in oAsistencias)
{
var retardo = asistencia.FechaHora.TimeOfDay - new TimeSpan(09, 00, 00) < new TimeSpan(0)?new TimeSpan(0):asistencia.FechaHora.TimeOfDay - new TimeSpan(09, 00, 00);
dgvAsistencias.Rows.Add(asistencia.NombreSucursal, asistencia.FechaHora, asistencia.NombreUsuario, retardo);
}
}
/// <summary>
/// Devuelve un listado de Roles
/// </summary>
/// <returns></returns>
public List <Rol> ObtenerRoles(Dictionary <string, object> filtros)
{
try
{
DataTable dtRoles = new DataTable();
miConexionSql = new Conexion();
XDocument filtrosXml = UtilDatos.ArmarFiltrosXml(filtros);
dtRoles = miConexionSql.EjecutarProcedure("Sp_ObtenerRoles", filtrosXml, "@filtrosXml");
List <Rol> lstRoles = MapearDataTableLista(dtRoles);
return(lstRoles);
}
catch (Exception ex)
{
throw ex;
}
}
private void btnAceptar_Click(object sender, System.EventArgs e)
{
// Se valida el usuario
this.UsuarioSel = UtilDatos.ObtenerUsuarioDeContrasenia(this.txtContrasenia.Text);
this.Valido = (this.UsuarioSel != null);
if (!this.Valido)
{
UtilLocal.MensajeAdvertencia("Usuario o contraseña inválidos.");
this.RegresarAContrasenia();
return;
}
// Se valida que el usuario esté activo
if (!this.UsuarioSel.Activo)
{
UtilLocal.MensajeAdvertencia("El Usuario especificado no está activo en el sistema.");
this.RegresarAContrasenia();
return;
}
// Se valida la sucursal, si aplica
if (this.MostrarSeleccionDeSucursal && this.SucursalID != GlobalClass.SucursalID)
{
bool bPermiso = UtilLocal.ValidarPermiso(this.UsuarioSel.UsuarioID, "Sistema.VerOtrasSucursales", true);
if (!bPermiso)
{
this.RegresarAContrasenia();
return;
}
}
// Se validan los permisos, si hay
if (this.Permisos != null)
{
var oResV = UtilDatos.ValidarUsuarioPermisos(this.UsuarioSel.UsuarioID, this.Permisos, this.CumplirTodosLosPermisos);
if (oResV.Error)
{
UtilLocal.MensajeAdvertencia(oResV.Mensaje);
this.RegresarAContrasenia();
return;
}
}
this.DialogResult = DialogResult.OK;
this.Close();
}
private void FijarDescripcion(string sNumeroDeParte)
{
var Partes = Datos.GetListOf <PartesView>(q => q.NumeroDeParte == sNumeroDeParte);
this.ParteIDSel = 0;
bool bSel = false;
if (Partes.Count > 0) // Se tiene que mostrar un listado
{
var Lista = new ObtenerElementoLista("Selecciona la parte que deseas utilizar o presiona el botón \"Ninguna\" si no es alguna de las listadas."
, Partes);
Lista.MostrarColumnas("Descripcion", "Marca", "Linea");
Lista.btnAceptar.Text = "&Seleccionar";
Lista.btnCerrar.Text = "&Ninguna";
if (Lista.ShowDialog(Principal.Instance) == DialogResult.OK)
{
// Se verifica si la parte tiene su máximo mayor a cero, lo cual indica que no puede ser 9500
int iParteID = Util.Entero(Lista.Sel["ParteID"]);
if (Datos.Exists <ParteMaxMin>(c => c.ParteID == iParteID && c.Maximo > 0))
{
UtilLocal.MensajeAdvertencia("Este artículo no puede ser 9500. Si no hay existencia, favor de reportarlo al Departamento de Compras.");
this.txtDescripcion.Text = "";
this.txtDescripcion.ReadOnly = true;
return;
}
this.txtDescripcion.Text = Util.Cadena(Lista.Sel["Descripcion"]);
this.ParteIDSel = iParteID;
// this.chkPaqueteria.Focus();
bSel = true;
}
}
else
{
// Se sugiere el nombre
var oProvGanV = (this.cmbLineaMarca.SelectedItem as ProveedoresMarcasLineasView);
if (oProvGanV != null)
{
this.txtDescripcion.Text = UtilDatos.GenerarSugerenciaNombreParte(oProvGanV.LineaID, oProvGanV.MarcaID, sNumeroDeParte);
}
}
this.txtDescripcion.ReadOnly = bSel;
}
private void Comisiones_Load(object sender, EventArgs eo)
{
// Se oculta el tab de logros. Se implementará en siguiente versión
this.tabComisiones.TabPages.Remove(this.tbpLogros);
// Se llenan los vendedores
this.cmbVendedor.CargarDatos("UsuarioID", "NombrePersona", Datos.GetListOf <Usuario>(q => q.Estatus));
// Se llenan los combos de fechas con los datos predeterminados
var oFechas = UtilDatos.FechasDeComisiones(DateTime.Today);
this.dtpDe.Value = oFechas.Valor1;
this.dtpA.Value = oFechas.Valor2;
// Se agrega una fila al grid de totales
this.dgvTotales.Rows.Add("TOTALES");
this.pnlUtVendedores.Visible = false;
//this.dgvGerentesComisiones.Visible = false;
// Los datos se mandan llenar desde el manejador (VentasComisiones) al Activar
}
private void LlenarPagos(int iVentaID)
{
var oPagos = Datos.GetListOf <VentasPagosView>(q => q.VentaID == iVentaID);
this.dgvAbonos.Rows.Clear();
string sFormaDePago, sVales = "";
foreach (var oPago in oPagos)
{
// Se obtiene el folio de cobranza, según el pago
var oCobranzaT = Datos.GetEntity <CobranzaTicket>(c => c.VentaPagoID == oPago.VentaPagoID);
string sTicket = (oCobranzaT == null ? "" : oCobranzaT.Ticket);
//
sFormaDePago = UtilDatos.VentaPagoFormasDePago(oPago.VentaPagoID);
if (sFormaDePago.Contains("NC"))
{
sVales = UtilDatos.VentaPagoVales(oPago.VentaPagoID);
}
this.dgvAbonos.Rows.Add(oPago.Fecha, sFormaDePago, sVales, oPago.VentaPagoID, oPago.Importe, sTicket);
}
}
protected override void btnGuardar_Click(object sender, EventArgs e)
{
try
{
if (!Validaciones())
{
return;
}
if (EsNuevo)
{
}
else
{
int iAutorizoID = 0;
var ResU = UtilLocal.ValidarObtenerUsuario(null, "Autorización");
if (ResU.Exito)
{
iAutorizoID = ResU.Respuesta.UsuarioID;
}
else
{
Util.MensajeError("Error al validar el usuario.", GlobalClass.NombreApp);
return;
}
SplashScreen.Show(new Splash());
this.btnGuardar.Enabled = false;
var ContingenciaCompleta = Datos.GetEntity <MovimientoInventarioContingenciasView>(c => c.MovimientoInventarioTraspasoContingenciaID == Contingencia.MovimientoInventarioTraspasoContingenciaID);
if (null == ContingenciaCompleta)
{
return;
}
//Actualiza la contingencia
Contingencia.FechaModificacion = DateTime.Now;
Contingencia.MovimientoInventarioEstatusContingenciaID = 1;
Contingencia.UsuarioID = GlobalClass.UsuarioGlobal.UsuarioID;
Contingencia.UsuarioSolucionoID = GlobalClass.UsuarioGlobal.UsuarioID;
Contingencia.FechaSoluciono = DateTime.Now;
Contingencia.TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue);
Contingencia.TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue);
Contingencia.ObservacionSolucion = this.txtObservacion.Text;
if (Util.Entero(this.cboTipoOperacion.SelectedValue) == Cat.TiposDeOperacionMovimientos.SalidaInventario)
{
Contingencia.ObservacionSolucion += (" - SE CREA UNA ENTRADA PARA DEVOLVER EL TRASPASO A LA TIENDA ORIGEN Y EN EL SEGUNDO MOVIMIENTO UNA SALIDA PARA PODER HACER LA SALIDA DEL INVENTARIO");
}
Contingencia.FechaModificacion = DateTime.Now;
Datos.SaveOrUpdate <MovimientoInventarioTraspasoContingencia>(Contingencia);
int iSucursalID = ContingenciaCompleta.SucursalOrigenID.Valor();
string sOrigen = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalOrigenID.Valor());
string sDestino = UtilDatos.NombreDeSucursal(ContingenciaCompleta.SucursalDestinoID.Valor());
var oPrecio = Datos.GetEntity <PartePrecio>(c => c.ParteID == ContingenciaCompleta.ParteID && c.Estatus);
switch (Util.Entero(cboTipoOperacion.SelectedValue))
{
case 2:
#region [ Entrada Inventario ]
//Insertar Movimiento
var movimientoEntradaI = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = 1,
ProveedorID = 1,
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
FechaFactura = DateTime.Now,
FechaRecepcion = DateTime.Now,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = ContingenciaCompleta.TipoConceptoOperacionID,
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar <MovimientoInventario>(movimientoEntradaI);
if (movimientoEntradaI.MovimientoInventarioID < 1)
{
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
var detalleMovimiento = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoEntradaI.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimiento);
//Actualizar ParteExistencia
/* var sucursalId = ContingenciaCompleta.SucursalOrigenID;
* var existencia = General.GetEntity<ParteExistencia>(p => p.ParteID == ContingenciaCompleta.ParteID && p.SucursalID == sucursalId);
* if (existencia != null)
* {
* existencia.Existencia += Util.ConvertirDecimal(ContingenciaCompleta.Diferencia);
* Datos.Guardar<ParteExistencia>(existencia);//dmod
* }
*/
// AdmonProc.AgregarExistencia(ContingenciaCompleta.ParteID, sucursalId.Valor(), ContingenciaCompleta.Diferencia.Valor()
// , Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
// Se modifica la existencia y el kardex
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Entrada"
, sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoEntradaI.MovimientoInventarioID);
#endregion
break;
case 3:
#region [ Salida Inventario ]
//Insertar Movimiento
var movimientoSalida = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
TipoPagoID = 1,
ProveedorID = 1,
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
FechaFactura = DateTime.Now,
FechaRecepcion = DateTime.Now,
FolioFactura = null,
Subtotal = null,
IVA = null,
ImporteTotal = 0,
FueLiquidado = false,
TipoConceptoOperacionID = Util.Entero(this.cboConceptoOperacion.SelectedValue),
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID),
Articulos = null,
Unidades = null,
Seguro = null,
ImporteTotalSinDescuento = null
};
Datos.Guardar <MovimientoInventario>(movimientoSalida);
if (movimientoSalida.MovimientoInventarioID < 1)
{
new EntityNotFoundException("MovimientoInventarioID", "MovimientoInventario");
return;
}
//Insertar MovimientoDetalle
var detalleMovimientoS = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = movimientoSalida.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleMovimientoS);
//No se descuenta por que ya se habia descontado en el traspaso anterior
// Ahora sí se generan dos registros en kardex, uno de entrada y luego uno de salida, para que al final quede igual
// Se hace así para mantener un registro de la operación
// Se hace primero la entrada
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.EntradaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
, sOrigen, sDestino, ContingenciaCompleta.Diferencia.Valor()
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
// Luego la salida
AdmonProc.AfectarExistenciaYKardex(ContingenciaCompleta.ParteID, iSucursalID, Cat.OperacionesKardex.SalidaTraspaso
, Contingencia.MovimientoInventarioID.ToString(), Contingencia.UsuarioSolucionoID.Valor(), "Conflicto Resuelto Salida"
, sOrigen, sDestino, (ContingenciaCompleta.Diferencia.Valor() * -1)
, oPrecio.Costo.Valor(), Cat.Tablas.MovimientoInventario, movimientoSalida.MovimientoInventarioID);
#endregion
break;
case 5:
#region [ Traspaso ]
//Almacenar traspaso
var traspaso = new MovimientoInventario()
{
TipoOperacionID = Util.Entero(this.cboTipoOperacion.SelectedValue),
SucursalOrigenID = ContingenciaCompleta.SucursalOrigenID,
SucursalDestinoID = ContingenciaCompleta.SucursalDestinoID,
ImporteTotal = 0,
FueLiquidado = false,
UsuarioSolicitoTraspasoID = Contingencia.UsuarioSolucionoID,
ExisteContingencia = false,
Observacion = string.Format("{0}: {1}", "Traspaso por resolucion de un Conflicto. Movimiento: ", Contingencia.MovimientoInventarioID)
};
Datos.Guardar <MovimientoInventario>(traspaso);
//Almacenar el detalle del traspaso
if (traspaso.MovimientoInventarioID > 0)
{
var detalleTraspaso = new MovimientoInventarioDetalle()
{
MovimientoInventarioID = traspaso.MovimientoInventarioID,
ParteID = ContingenciaCompleta.ParteID,
Cantidad = Util.Decimal(ContingenciaCompleta.Diferencia),
PrecioUnitario = 0,
Importe = 0,
FueDevolucion = false,
FechaRegistro = DateTime.Now,
Estatus = true
};
Datos.SaveOrUpdate <MovimientoInventarioDetalle>(detalleTraspaso);
//No se descuenta por que ya se habia descontado en el primer traspaso
}
#endregion
break;
default:
break;
}
}
SplashScreen.Close();
this.btnGuardar.Enabled = true;
new Notificacion("Conflicto Resuelto exitosamente", 2 * 1000).Mostrar(Principal.Instance);
catalogosTraspasos.Instance.CustomInvoke <catalogosTraspasos>(m => m.ActualizarListadoConflictos());
}
catch (Exception ex)
{
SplashScreen.Close();
this.btnGuardar.Enabled = true;
Util.MensajeError(ex.Message, GlobalClass.NombreApp);
}
this.Close();
}
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));
}
}
}
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);
}
public static void InicializarSesion(int iSucursalID, Usuario oUsuario)
{
// Se llenan datos globales
GlobalClass.SucursalID = iSucursalID;
GlobalClass.NombreTienda = Datos.GetEntity <Sucursal>(s => s.SucursalID == iSucursalID && s.Estatus).NombreSucursal;
// Se llenan los datos del Usuario
UtilLocal.LlenarUsuarioGlobal(oUsuario);
// Se llena el título
Principal.Instance.LlenarTitulo();
// Se llenan los datos en la librería de TheosProc,
Theos.SucursalID = iSucursalID;
Theos.UsuarioID = oUsuario.UsuarioID;
Theos.Iva = GlobalClass.ConfiguracionGlobal.IVA;
Theos.RutaImagenes = GlobalClass.ConfiguracionGlobal.pathImagenes;
Theos.Titulo = GlobalClass.NombreApp;
//Se verifica si el usuario ya se ha logueado este dia para tomar asistencia
var fechaHora = UtilDatos.FechaServidorDeDatos();
if (!Datos.Exists <UsuarioAsistencia>(u => u.AccesoUsuarioID == oUsuario.UsuarioID && EntityFunctions.TruncateTime(u.FechaHora) == fechaHora.Date))
{//Si no, se registra
UsuarioAsistencia oAsistencia = new UsuarioAsistencia()
{
AccesoUsuarioID = oUsuario.UsuarioID,
SucursalID = GlobalClass.SucursalID,
FechaHora = fechaHora
};
Datos.Guardar <UsuarioAsistencia>(oAsistencia);
}
// Se registra la ip acutal del usuario
string sIp = Util.IpLocal();
if (oUsuario.Ip != sIp)
{
oUsuario.Ip = sIp;
Datos.Guardar <Usuario>(oUsuario);
}
// Se inicializa el socket de escucha, si aplica
if (oUsuario.Alerta9500.Valor())
{
//
if (Proc.oEscucha != null)
{
Proc.oEscucha.Detener();
}
//
Proc.oEscucha = new ServidorTcp(GlobalClass.Puerto);
Proc.oEscucha.ConexionRecibida += oEscucha_ConexionRecibida;
Proc.oEscucha.Escuchar();
// Proc.oEscucha.Probar();
}
// Se configuran los recordatorios para Pedidos a Proveedores, si aplica
if (oUsuario.AlertaPedidos.Valor())
{
DateTime dManiana = DateTime.Now.Date.AddDays(1);
var oAlertas = Datos.GetListOf <ProveedorEventoCalendario>(c => c.Fecha < dManiana && !c.Revisado);
foreach (var oReg in oAlertas)
{
if (oReg.Fecha < DateTime.Now)
{
Admon.MostrarRecordatorioPedidos(oReg.ProveedorEventoCalendarioID);
}
else
{
Program.oTimers.Add("AlertaPedido" + Program.oTimers.Count.ToString(), new System.Threading.Timer(new TimerCallback(Admon.MostrarRecordatorioPedidos)
, oReg.ProveedorEventoCalendarioID, (int)(oReg.Fecha - DateTime.Now).TotalMilliseconds, Timeout.Infinite));
}
}
}
// Se verifica la alterta de traspasos
if (oUsuario.AlertaTraspasos.Valor())
{
if (Datos.Exists <MovimientoInventarioTraspasoContingencia>(
c => c.MovimientoInventarioEstatusContingenciaID == Cat.TraspasosContingenciasEstatus.NoSolucionado))
{
UtilLocal.MensajeAdvertencia("Existen conflictos de traspasos sin resolver.");
}
}
// Se configuran los recordatorios para Cobros a Clientes, si aplica
if (oUsuario.AlertaCalendarioClientes.Valor())
{
Eventos.Instance.Show();
}
// Se configuran los recordatorios para conteos de inventario, si aplica
if (Datos.Exists <InventarioUsuario>(c => c.InvUsuarioID == GlobalClass.UsuarioGlobal.UsuarioID))
{
Asincrono.ProcesoHora(Principal.Instance.MostrarMensaje, new DosVal <string, string>("Recordatorio de Inventario", "Te recordamos realizar el inventario."), 9, 10);
Asincrono.ProcesoHora(UtilLocal.VerInventarioConteoPendiente, null, 18, 00);
// Asincrono.ProcesoHora(UtilLocal.VerInventarioConteoPendiente, null, 13, 16);
}
}
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 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);
}
