/// <summary>
/// Realiza la carga de los bloques asignados a un detalle de autorización y bloque padre
/// </summary>
/// <param name="id_autorizacion_detalle">Id de Detalle de Autorización</param>
/// <param name="id_bloque_superior">Id de Bloque superior</param>
/// <returns></returns>
public static DataTable CargaBloquesAutorizacionDetalle(int id_autorizacion_detalle, int id_bloque_superior)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Definiendo arreglo de objetos que contendrá al conjunto de criterios de consulta
object[] param = { 5, 0, id_autorizacion_detalle, 0, id_bloque_superior, 0, 0, false, "", "" };
//Realizando la búsqueda en BD
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nombre_stored_procedure, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando origen de datos
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Método encargado de Obtener los Proveedores de FTP
/// </summary>
/// <param name="id_compania"></param>
/// <returns></returns>
public static DataTable ObtieneProveedoresFTP(int id_compania)
{
//Declarando Objeto de Retorno
DataTable dtProveedoresFTP = null;
//Creación del arreglo que alamcena los datos necesarios para insertar un registro
object[] param = { 4, 0, id_compania, 0, 0, "", "", "", 0, "", "", 0, false, "", "" };
//Obteniendo Datos
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nom_sp, param))
{
//Validando Resultado
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando Valores Obtenidos
dtProveedoresFTP = ds.Tables["Table"];
}
}
//Devolviendo Resultado Obtenido
return(dtProveedoresFTP);
}
/// <summary>
/// Busca e instancía el timbre fiscal digital del comprobante solicitado
/// </summary>
/// <param name="id_comprobante">Id de Comprobante</param>
/// <returns></returns>
public static TimbreFiscalDigital RecuperaTimbreFiscalComprobante(int id_comprobante)
{
//Definiendo objeto de retorno
TimbreFiscalDigital timbre = new TimbreFiscalDigital();
//Realizando la carga de los timbres del comprobante
using (DataTable mit = CargaTimbresFiscalesComprobante(id_comprobante))
{
//Si el origen es válido
if (Validacion.ValidaOrigenDatos(mit))
{
//Para cada uno de los registros
foreach (DataRow r in mit.Rows)
{
timbre = new TimbreFiscalDigital(Convert.ToInt32(r["IdTimbreFiscalDigital"]));
}
}
}
//Devolviendo resultado
return(timbre);
}
/// <summary>
/// Método encargado de Obtener el Reporte de los Movimientos Generales
/// </summary>
/// <param name="id_compania_emisora">Compania Emisora</param>
/// <param name="id_servicio">No. Servicio</param>
/// <param name="id_estatus_mov">Estatus Movimiento</param>
/// <param name="id_tipo_mov">Tipo de Movimiento</param>
/// <param name="id_parada_origen">Parada Origen</param>
/// <param name="id_parada_destino">Parada Destino</param>
/// <param name="id_tipo_asignacion">Tipo de Asignación</param>
/// <param name="id_recurso_asignado">Recurso Asignado</param>
/// <returns></returns>
public static DataTable BuscarMovimiento(int id_compania_emisora, int no_servicio, string no_viaje, decimal secuencia, int id_parada_origen, int id_parada_destino)
{
//Declarando Objeto de Retorno
DataTable dtMovimientos = null;
//Armando Arreglo de Parametros
object[] param = { 7, id_compania_emisora, no_servicio, no_viaje, secuencia, id_parada_origen, id_parada_destino, "", "", "", "", "", "", "", "", "", "", "", "", "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nombre_store_procedure, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
dtMovimientos = ds.Tables["Table"];
}
}
//Devolviendo Resultado Obtenido
return(dtMovimientos);
}
/// <summary>
/// Carga los Terceros para Asignación de Recurso en Despacho
/// </summary>
/// <param name="id_compania_emisor">Id Compania Emisor</param>
/// <param name="nombre">Nombre del Tercero</param>
/// <returns></returns>
public static DataTable CargaTercerosParaAsignacionEnDespacho(int id_compania_emisor, string nombre)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Declarando arreglo de parámetros para consulta en BD
object[] param = { 6, 0, "", "", nombre, "", 0, false, false, false, 0, "", "", "", 0, 0, id_compania_emisor, 0, "", "", 0, 0, 0, false, "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Método que realiza la busqueda y asignación de inventario Llanta
/// </summary>
/// <param name="id_inventario_llanta">Identifica el registro de InventarioLlanta</param>
/// <returns></returns>
private bool cargaAtributos(int id_inventario_llanta)
{
//Creación del objeto retorno
bool retorno = false;
//Creación del arreglo que almacena los datos necesarios para realizar la busqueda de un registro de inventario llanta
object[] param = { 3, id_inventario_llanta, 0, 0, 0, null, null, null, 0, 0, 0, 0, 0, null, 0, 0, false, "", "" };
//Invoca y asigna al dataset el método que realiza la busqueda de un registro de Inventario Llanta
using (DataSet DS = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nom_sp, param))
{
//Valida los datos asignados al dataset(que no sean nulos)
if (Validacion.ValidaOrigenDatos(DS.Tables[0]))
{
//Si existen datos en el dataset, recorre la fila y cada campo del registro lo alamcena en los atributos de la clase
foreach (DataRow r in DS.Tables[0].Rows)
{
this._id_inventario_llanta = id_inventario_llanta;
this._consecutivo = Convert.ToInt32(r["Consecutivo"]);
this._id_inventario = Convert.ToInt32(r["IdInventario"]);
this._id_actividad = Convert.ToInt32(r["IdActividad"]);
this._fecha_inicio = Convert.ToDateTime(r["FechaInicio"]);
this._fecha_fin = Convert.ToDateTime(r["FechaFin"]);
this._fecha_compra = Convert.ToDateTime(r["FechaCompra"]);
this._mm_inicio = Convert.ToInt32(r["MMInicio"]);
this._id_proveedor = Convert.ToInt32(r["IdProveedor"]);
this._id_factura = Convert.ToInt32(r["IdFactura"]);
this._costo = Convert.ToDecimal(r["Costo"]);
this._kms = Convert.ToDecimal(r["Kms"]);
this._fecha_garantia = Convert.ToDateTime(r["FechaGarantia"]);
this._kms_garantia = Convert.ToInt32(r["KmsGarantia"]);
this._habilitar = Convert.ToBoolean(r["Habilitar"]);
}
//Cambia de valor al objeto retorno
retorno = true;
}
}
//Retorna al método el objeto retorno
return(retorno);
}
/// <summary>
/// Método encargado de Obtener las Asignaciones ligadas a la Orden de Trabajo
/// </summary>
/// <param name="id_orden_trabajo">Orden de Trabajo</param>
/// <returns></returns>
public static DataTable ObtieneAsignacionesOrdenTrabajo(int id_orden_trabajo)
{
//Declarando Objeto de Retorno
DataTable dtAsignaciones = null;
//Armando Arreglo de Parametros
object[] param = { 3, id_orden_trabajo, "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", };
//Obteniendo Reporte
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando Valor Obtenido
dtAsignaciones = ds.Tables["Table"];
}
}
//Devolviendo Resultado Obtenido
return(dtAsignaciones);
}
public FrmNewModClientes(Clientes clientes)
{
InitializeComponent();
_cliente = new Clientes();
_provincia = new Provincia();
_estado = new Estado();
validar = new Validacion();
Validacion.combo2campos(cboProv, "DescripcionProvincia", "IdProvincia", "Provincia");
Validacion.combo2campos(cboEstadoCli, "DescripcionEstado", "IdEstado", "Estado");
if (clientes != null)
{
btnGuardar.Visible = false;
btnGuardar.Enabled = false;
txtCodigoClientes.Enabled = false;
txtCodigoClientes.Text = Convert.ToInt32(clientes.IdCliente.ToString()).ToString();
txtCuit.Text = clientes.CuitCuil;
txtRazonSocial.Text = clientes.RazonSocial;
txtDireccion.Text = clientes.Direccion;
txtLocalidad.Text = clientes.Localidad;
cboProv.Text = clientes.provincia.DescripcionProvincia;
txtTel1.Text = clientes.Tel1;
txtTel2.Text = clientes.Tel2;
TxtEmail.Text = clientes.Email;
cboEstadoCli.Text = clientes.estado.DescripcionEstado;
Accion = "MODIFICAR";
}//end-if
else
{
btnModificar.Enabled = false;
btnModificar.Visible = false;
txtCodigoClientes.Visible = false;
lblCodigoCliente.Visible = false;
Accion = "ALTA";
}
}//constuctor
/// <summary>
/// Método encargado de llenar la nómina
/// </summary>
private void cargaNominaEmpleado()
{
//Declarar variables de fecha
DateTime fec_pago_i, fec_pago_f, fec_nomi_i, fec_nomi_f;
fec_pago_i = fec_pago_f = fec_nomi_i = fec_nomi_f = DateTime.MinValue;
//Falidar fechas solicitadas
if (chkFiltroPago.Checked)
{
//Obtener fechas
DateTime.TryParse(txtFechaInicio.Text, out fec_pago_i);
DateTime.TryParse(txtFechaFin.Text, out fec_pago_f);
}
if (chkFiltroNomina.Checked)
{
//Obtener fechas
DateTime.TryParse(txtFechaInicio.Text, out fec_nomi_i);
DateTime.TryParse(txtFechaFin.Text, out fec_nomi_f);
}
//Obtener reporte
using (DataTable dtReporteNominaEmpleados = SAT_CL.Nomina.Reporte.ObtieneReporteNominaEmpleados(Convert.ToInt32(Cadena.RegresaCadenaSeparada(txtEmpleado.Text, "ID:", 1, "0")), Convert.ToInt32(txtNoNomina.Text == "" ? "0" : txtNoNomina.Text), fec_pago_i, fec_pago_f, fec_nomi_i, fec_nomi_f, Convert.ToByte(ddlEstatus.SelectedValue), ((SAT_CL.Seguridad.UsuarioSesion)Session["usuario_sesion"]).id_compania_emisor_receptor))
{
if (Validacion.ValidaOrigenDatos(dtReporteNominaEmpleados))
{
//Cargar GV
Controles.CargaGridView(gvNominaEmpleados, dtReporteNominaEmpleados, "Id", lblOrdenado.Text, true, 1);
//Añadiendo resultado a sesion
Session["DS"] = TSDK.Datos.OrigenDatos.AñadeTablaDataSet((DataSet)Session["DS"], dtReporteNominaEmpleados, "Table");
}
else
{
//Inicializa GridView
Controles.InicializaGridview(gvNominaEmpleados);
//Eliminando resultado de session
Session["DS"] = TSDK.Datos.OrigenDatos.EliminaTablaDataSet((DataSet)Session["DS"], "Table");
}
}
sumaTotales();
}
/// <summary>
/// Método encargado de Obtener los Conceptos del Comprobante
/// </summary>
/// <param name="id_comprobante"></param>
/// <returns></returns>
public static DataTable ObtieneConceptosComprobante(int id_comprobante)
{
//Declarando Objeto de Retorno
DataTable dtConceptos = null;
//Armando Arreglo de Parametros
object[] param = { 4, 0, id_comprobante, 0, 0.00M, 0, 0, 0, "", "", 0.00M, 0.00M, 0.00M, "", 0.00M, 0, false, "", "" };
//Instanciando Resultados Obtenidos
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando que existan Datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando Resultado Obtenido
dtConceptos = ds.Tables["Table"];
}
}
//Devolviendo Resultado Obtenido
return(dtConceptos);
}
/// <summary>
/// Método encargado de cargar los Operadores ligado a una Unidad
/// </summary>
private void cargaHistorialOperador()
{
//Obtenemos Operadores
using (DataTable mit = SAT_CL.Global.AsignacionOperadorUnidad.CargaOperadores(Convert.ToInt32(gvUnidades.SelectedDataKey["IdUnidad"])))
{
//Validando que el DataSet contenga las tablas
if (Validacion.ValidaOrigenDatos(mit))
{
//Cargando los GridView
Controles.CargaGridView(gvHisOperador, mit, "Id", "", false, 0);
//Añadiendo Tablas al DataSet de Session
Session["DS"] = OrigenDatos.AñadeTablaDataSet((DataSet)Session["DS"], mit, "Table2");
}
else
{ //Inicializando GridViews
Controles.InicializaGridview(gvHisOperador);
//Eliminando Tablas del DataSet de Session
Session["DS"] = OrigenDatos.EliminaTablaDataSet((DataSet)Session["DS"], "Table2");
}
}
}
private void btnAceptar_Click(object sender, EventArgs e)
{
errorProvider1.Dispose();
var valido = Validacion.Validar(errorProvider1, new List <object>
{
txtPrecioConIVA,
txtPrecioSinIVA,
txtCostoConIVA,
txtCostoSinIVA
});
if (valido)
{
Precio = txtPrecioConIVA.Valor.GetValueOrDefault();
Costo = txtCostoConIVA.Valor;
}
else
{
DialogResult = DialogResult.None;
}
}
/// <summary>
/// Método encargado de Obtener los Parametros del Web Service del Proveedor
/// </summary>
/// <param name="id_tabla">Id Tabla</param>
/// <param name="id_registro">Id Registro</param>
/// <returns></returns>
public static DataTable ObtieneRegistrosDiccionarioWS(int id_tabla, int id_registro)
{
//Declarando Objeto de Retorno
DataTable dt = null;
//Armando Arreglo de Parametros
//object[] param = { 0, "", "", "", "" };
object[] param = { 4, 0, 0, id_tabla, id_registro, 0, "", 0, "", "", 0, true, "", "" };
//Obteniendo Parametros
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nom_sp, param))
{
//Validando que existan Registros
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando Valor
dt = ds.Tables["Table"];
}
}
//Devolviendo Resultado Obtenido
return(dt);
}
/*
* Realizar una clase llamada Validacion que posea un método estático llamado Validar, que posea la siguiente firma: bool Validar(int valor, int min, int max):
* a. valor: dato a validar
* b. min y max: rango en el cual deberá estar la variable valor.
* Pedir al usuario que ingrese 10 números enteros. Validar con el método desarrollado anteriormente que esten dentro del rango -100 y 100.
* Terminado el ingreso mostrar el valor mínimo, el valor máximo y el promedio.
* Nota: Utilizar variables escalares, NO utilizar vectores.*/
static void Main(string[] args)
{
int ingreso;
int max = int.MinValue;
int min = int.MaxValue;
int i = 0; // Variable que se usara para iterar en el DO WHILE
int acumulado = 0; // Se inicializa la variable acumulador en cero
float promedio;
Console.Title = "Ejercicio Numero 11";
do
{
Console.Clear();
Console.WriteLine($"Ingrese el numero {i}: ");
int.TryParse(Console.ReadLine(), out ingreso);
if (Validacion.Validar(ingreso, -100, 100))
{
if (i == 0 || ingreso > max)
{
max = ingreso;
}
if (i == 0 || ingreso < min)
{
min = ingreso;
}
acumulado += ingreso;
i++;
}
else
{
Console.WriteLine("Error. Debe ingresas un numero mayor que -100 y menor que 100");
Console.ReadKey();
}
} while (i < 10);
promedio = (float)acumulado / i;
Console.WriteLine($"El maximo es {max}, el minimo es {min} y el promedio es {promedio}");
Console.ReadKey();
}
/// <summary>
/// Carga todos los controles
/// </summary>
/// <param name="id_accion">Id Accion</param>
/// <returns></returns>
public static DataTable CargaControles(byte id_accion)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Inicialziando los parámetros de consulta
object[] param = { 5, 0, 0, 0, "", "", id_accion, 0, false, "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Validamos versión de Registro desde la Base de Datos y Instancia creada
/// </summary>
/// <returns></returns>
private bool validaVersionRegistro()
{
//Declaramos Resultado
bool resultado = false;
//Inicializando arreglo de parámetros
object[] param = { 4, this._id_segmento_carga, 0, 0, 0, 0, 0, 0, 0, false, this._row_version, "", "" };
//Obtenemos Resultados
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nombre_stored_procedure, param))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Establecemos Resultado correcto
resultado = true;
}
}
//Obtenemos Resultado
return(resultado);
}
/// <summary>
/// Método encargado de Buscar los Saldos Globales
/// </summary>
private void buscaSaldosGlobales()
{
//Obteniendo Fechas
DateTime fec_ini = DateTime.MinValue, fec_fin = DateTime.MinValue;
//Validando que se Incluyan las Fechas
if (chkIncluir.Checked)
{
//Obteniendo Fechas
DateTime.TryParse(txtFecIni.Text, out fec_ini);
DateTime.TryParse(txtFecFin.Text, out fec_fin);
}
//Obteniendo Reporte de Saldos Globales
using (DataTable dtSaldosGlobales = Reporte.ObtieneReporteSaldoGlobal(((SAT_CL.Seguridad.UsuarioSesion)Session["usuario_sesion"]).id_compania_emisor_receptor,
Convert.ToInt32(TSDK.Base.Cadena.RegresaCadenaSeparada(txtCliente.Text, "ID:", 1)), fec_ini, fec_fin, Convert.ToByte(chkFacturacinE.Checked)))
{
//Validando que existan Registros
if (Validacion.ValidaOrigenDatos(dtSaldosGlobales))
{
//Cargando GridView
Controles.CargaGridView(gvSaldosGlobales, dtSaldosGlobales, "Cliente", "", true, 0);
//Añadiendo Tabla a Session
Session["DS"] = OrigenDatos.AñadeTablaDataSet((DataSet)Session["DS"], dtSaldosGlobales, "Table");
}
else
{
//Inicializando GridView
Controles.InicializaGridview(gvSaldosGlobales);
//Eliminando Tabla de Session
Session["DS"] = OrigenDatos.EliminaTablaDataSet((DataSet)Session["DS"], "Table");
}
//Invocando Método de Suma
sumaTotalesGlobales();
}
}
/// <summary>
/// Buscamos segmento en estatus iniciado ligando una parada origen
/// </summary>
/// <param name="id_servicio">Id Servicio</param>
/// <param name="id_parada_origen">Id parada Destino</param>
/// <returns></returns>
public static int BuscamosSegmentoParadaOrigen(int id_servicio, int id_parada_origen)
{
//Declaramos variable segmento
int id_segmento = 0;
//Inicializando arreglo de parámetros
object[] param = { 13, 0, id_servicio, 0, 0, id_parada_origen, 0, 0, 0, false, null, "", "" };
//Obtenemos Resultados
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nombre_stored_procedure, param))
{
//Validamos Origen de Datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Obtenemos el movimiento
id_segmento = (from DataRow r in ds.Tables[0].Rows
select Convert.ToInt32(r["IdSegmento"])).FirstOrDefault();
}
}
//Devolvemos Valor
return(id_segmento);
}
/// <summary>
/// Mètodo encargado de cargar las Actividades por nAsignar
/// </summary>
/// <param name="id_compania_emisor">Id Compania Emisor</param>
/// <param name="no_orden">No Orden</param>
/// <param name="id_estatus">Id Estatus</param>
/// <param name="id_tipo_unidad">Id Tipo Unidad</param>
/// <param name="id_sub_tipo_unidad">Id Sub Tipo Unidad</param>
/// <param name="unidad">Unidad</param>
/// <param name="id_familia">Id Familia</param>
/// <param name="id_sub_familia">Id Sub Familia</param>
/// <param name="fecha_inicio_orden_trabajo">Fecha de Inicio de Orden de Trabajo</param>
/// <param name="fecha_fin_orden_trabajo">Fecha Fin de Orden de Trabajo</param>
/// <returns></returns>
public static DataTable CargaActividadesPorAsignar(int id_compania_emisor, string no_orden, string id_estatus, int id_tipo_unidad, byte id_sub_tipo_unidad,
string unidad, byte id_familia, byte id_sub_familia, DateTime fecha_inicio_orden_trabajo, DateTime fecha_fin_orden_trabajo)
{
//Declarando Objeto retorno
DataTable mit = null;
//Armando Arreglo de Parametros
object[] param = { 1, id_compania_emisor, no_orden, id_estatus, id_tipo_unidad, id_sub_tipo_unidad,
unidad, id_familia, id_sub_familia, fecha_inicio_orden_trabajo == DateTime.MinValue ? "" : fecha_inicio_orden_trabajo.ToString("dd/MM/yyyy HH:mm"), fecha_fin_orden_trabajo == DateTime.MinValue ? "" : fecha_fin_orden_trabajo.ToString("dd/MM/yyyy HH:mm"), "", "","", "", "", "", "", "", "", "", };
//Obteniendo Reporte
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
mit = ds.Tables["Table"];
}
}
//Devolviendo Resultado Obtenido
return(mit);
}
/// <summary>
/// Método encargado de Obtener los Segmentos con su Hoja de Instrucción Calculada
/// </summary>
/// <param name="id_servicio">Servicio</param>
/// <returns></returns>
public static DataTable CargaSegmentosHI(int id_servicio)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Inicializando arreglo de parámetros
object[] param = { 16, 0, id_servicio, 0, 0, 0, 0, 0, 0, false, null, "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nombre_stored_procedure, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Carga los datos de requeridos del servicio para su envío a Omnitracs
/// </summary>
/// <param name="id_servicio">Id de Servicio</param>
/// <param name="id_proveedor_ftp">Proveedor FTP (GPS)</param>
/// <returns></returns>
public static DataTable CargaInformacionServicioOmnitracs(int id_servicio, int id_proveedor_ftp)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Inicializando los parámetros de consulta
object[] parametros = { 5, id_servicio, "", "", id_proveedor_ftp, "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nombre_store_procedure, parametros))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Carga Historial de Bitácora de acuerdo a una Entidad
/// </summary>
/// <param name="id_tabla">Id Tabla entidad</param>
/// <param name="id_registro">Id Registro</param>
/// <param name="fecha_inicio">Permite definir un parametro de busqueda entre una fecha inicial</param>
/// <param name="fecha_fin">Perite definir un limite de busqueda por fecha</param>
/// <param name="id_tipo_bitacora_monitoreo">Permite definir un tipo de busqueda(Posicionamiento, robo, Accidente,etc)</param>
/// <param name="no_servicio">No. de Servicio</param>
/// <returns></returns>
public static DataTable CargaHistorialBitacoraMonitoreo(int id_tabla, int id_registro, DateTime fecha_inicio, DateTime fecha_fin, byte id_tipo_bitacora_monitoreo, string no_servicio)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Inicializando arreglo de parámetros
object[] param = { 4, 0, 0, id_tipo_bitacora_monitoreo, 0, 0, 0, 0, id_tabla, id_registro, SqlGeography.Null, no_servicio, "", null, 0.00M, false, 0, false, fecha_inicio.ToString(ConfigurationManager.AppSettings["FormatoFechaReportes"]), fecha_fin.ToString(ConfigurationManager.AppSettings["FormatoFechaReportes"]) };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nombre_stored_procedure, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Carga Casetas ligando un Id de Ruta
/// </summary>
/// <param name="id_ruta"></param>
/// <returns></returns>
public static DataTable CargaCasetas(int id_ruta)
{
//Creación del arreglo que almacena los datos necesarios para realizar la busqueda de una RutaCaseta
object[] param = { 4, 0, id_ruta, 0, 0, 0, 0, false, "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nom_sp, param))
{
//Definiendo objeto de retorno
DataTable mit = null;
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Método encargado de Cargar las Imagenes de Incidencia del Monitoreo
/// </summary>
/// <param name="id_bitacora_monitoreo">Bitacora de Monitoreo</param>
/// <returns></returns>
public static DataTable CargaImagenesBitacoraMonitoreo(int id_bitacora_monitoreo)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Inicializando arreglo de parámetros
object[] param = { 6, id_bitacora_monitoreo, 0, 0, 0, 0, 0, 0, 0, 0, SqlGeography.Null, "", "", null, 0.00M, false, 0, false, "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nombre_stored_procedure, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
}
//Devolviendo resultado
return(mit);
}
/// <summary>
/// Método encargado de Obtener el Resultado de la Evaluación
/// </summary>
/// <param name="id_eta">Evaluación</param>
/// <returns></returns>
public static DataTable ObtieneResultadoEvaluacion(int id_eta)
{
//Declarando Objeto de Retorno
DataTable dtETA = null;
//Creando Arreglo de Parametros
object[] param = { 4, id_eta, 0, null, 0, 0, 0, 0, null, null, 0, false, "", "" };
//Instanciando Registro
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando que exista el Registro
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando Valores
dtETA = ds.Tables["Table"];
}
}
//Devolviendo Resultado Obtenido
return(dtETA);
}
/// <summary>
/// Realiza la carga del registro Impuesto del comprobante solicitado, en el formato de tabla
/// </summary>
/// <param name="id_comprobante">Id de Comprobante</param>
/// <param name="transaccion">Transacción</param>
/// <returns></returns>
public static DataTable CargaImpuestoComprobante(int id_comprobante, SqlTransaction transaccion)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Inicializando parametros
object[] parametros = { 5, 0, id_comprobante, 0, 0, 0, 0, 0, false, "", "" };
//Instanciando dataset con resultado de consulta
using (DataSet DS = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nombre_stored_procedure, parametros, transaccion))
{
//Validando datos
if (Validacion.ValidaOrigenDatos(DS, "Table"))
{
//Asignando resultado
mit = DS.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Método encargado de Obtener las relaciones de la Nota de Credito
/// </summary>
/// <param name="id_facturado_egreso">Nota de Credito</param>
/// <returns></returns>
public static DataTable ObtieneRelacionesNotaCredito(int id_facturado_egreso)
{
//Declarando Objeto de Retorno
DataTable dtRelaciones = null;
//Armando arreglo de Parametros
object[] param = { 4, 0, id_facturado_egreso, 0, 0, 0, 0, true, "", "" };
//Instanciando Datos del SP
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando Datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando Datos
dtRelaciones = ds.Tables["Table"];
}
}
//Devovliendo Resultado Obtenido
return(dtRelaciones);
}
/// <summary>
/// Cargos Unidades Motrices que permitan la asignación unidades de Arrastre
/// </summary>
/// <param name="id_configuraciones_asignacion_recurso">Id Configuración asignación recurso</param>
/// <returns></returns>
public static DataTable CargaUnidadesMotricesPermitanArrastre(int id_configuraciones_asignacion_recurso)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Armando Objeto de Parametros
object[] param = { 6, 0, id_configuraciones_asignacion_recurso, 0, 0, 0, 0, 0, false, "", "" };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}
/// <summary>
/// Determina si es posible eliminar una aplicación de pago de Cliente, en base a su relación con un CFDI de Recepción de Pagos Activo
/// </summary>
/// <param name="id_tabla_origen_aplicacion"></param>
/// <param name="id_aplicacion_pago"></param>
/// <returns></returns>
public static RetornoOperacion ValidarAplicacionEnCFDIRecepcionPagoActivo(int id_tabla_origen_aplicacion, int id_aplicacion_pago)
{
//Declarando objeto de resultado
RetornoOperacion resultado = new RetornoOperacion(id_aplicacion_pago);
//Creando arreglo de parámetros para deshabilitación
object[] param = { 6, 0, Convert.ToByte(id_tabla_origen_aplicacion == 9 ? TipoOperacion.Ingreso : TipoOperacion.Egreso), 0, 0, 0, 0, id_aplicacion_pago, 0, 0, 0, 0, 0, 0, 0, "", "" };
//Realizando búsqueda de los registros que impidan elimiar Aplicación de Pago
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(_nom_sp, param))
{
//Validando resultados
if (Validacion.ValidaOrigenDatos(ds, true, true))
{
//Si hay resultados
resultado = new RetornoOperacion("Existe una Relación Activa a un CFDI de Recepción de Pagos Vigente.");
}
}
//Devolviendo resultado
return(resultado);
}
/// <summary>
/// Carga Historial de Lectura
/// </summary>
/// <param name="id_unidad">Id Unidad</param>
/// <param name="fecha_inicio">Fecha de Inicio de la Lectura</param>
/// <param name="fecha_fin">Fecha de Fin de la Lectura</param>
/// <returns></returns>
public static DataTable CargaHistorialLectura(int id_unidad, DateTime fecha_inicio, DateTime fecha_fin)
{
//Definiendo objeto de retorno
DataTable mit = null;
//Creación del arreglo de tipo objeto, con los parametros necesarios para consultar a la base de datos y estraer el registro requerido.
object[] param = { 4, 0, null, id_unidad, 0, "", 0, 0, 0, 0, "", 0, false, fecha_inicio.ToString(ConfigurationManager.AppSettings["FormatoFechaReportes"]), fecha_fin.ToString(ConfigurationManager.AppSettings["FormatoFechaReportes"]) };
//Realizando la consulta
using (DataSet ds = CapaDatos.m_capaDeDatos.EjecutaProcAlmacenadoDataSet(nom_sp, param))
{
//Validando origen de datos
if (Validacion.ValidaOrigenDatos(ds, "Table"))
{
//Asignando a objeto de retorno
mit = ds.Tables["Table"];
}
//Devolviendo resultado
return(mit);
}
}