public static List <List <String> > usuarios = new List <List <String> >(); //Lista de las cuentas a generar.
#endregion
#region Contructor
public ControladorSGC()
{
_conexionLDAP = new ConexionLDAP();
_conexionAD = new ConexionAD();
_conexionBD = new ManejoBD();
_conexionSGC = new ManejoBDSGC();
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que encuentra si hay un horario dado
/// </summary>
/// <param name="idSemestre">Id del semestre a buscar un horario</param>
/// <param name="idLugar">Id del lugar que se quiere ver su horario</param>
/// <returns>Retorna un int con el id del Horario o -1 en caso de error</returns>
public int obtenerHorario(int idSemestre, int idLugar)
{
int resultado = -1;
SqlCommand consultar = new SqlCommand("SP_HOR_ConsultarHorario", _conexion);
consultar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[2];
parametros[0] = new SqlParameter("@idLugar", SqlDbType.Int);
parametros[0].Value = idLugar;
parametros[1] = new SqlParameter("@idSemestre", SqlDbType.Int);
parametros[1].Value = idSemestre;
consultar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = consultar.ExecuteReader();
reader.Read();
resultado = reader.GetInt32(0);
_conexion.Close();
return(resultado);
}
catch (Exception ex) // Si algo falla se reporta el error en la Bitácora de Errores del sistema
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(-1);
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que elimina una entrada en la tabla BitacoraError
/// </summary>
/// <param name="idBitError">PK de la entrada que se quiere borrar</param>
/// <returns>Retorna una valor booleano indicando si tuvo éxito (true) o no (false)</returns>
public Boolean eliminarBitacoraError(int idBitError)
{
Boolean resultado = false;
SqlCommand eliminar = new SqlCommand("SP_SIS_EliminarBitError", _conexion);
eliminar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[1];
parametros[0] = new SqlParameter("@idBitacoraError", SqlDbType.Int);
parametros[0].Value = idBitError;
eliminar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = eliminar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
return(resultado);
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_conexionBD = new ManejoBD();
_conexionBD.insertarBitacoraError(ex.ToString(), "");
return(false);
}
}
/// <summary>
/// Método que se encarga de consultar el stored procedure que consulta si hay algún horario de disponibilidad habilitado
/// </summary>
/// <returns>Retorna un valor numérico de acuerdo al resultado obtenido (-1: en caso de error, 0: Deshabilitados, 1: Habilitado)</returns>
public int consultarHorarioActivo()
{
int resultado = -1;
SqlCommand consultar = new SqlCommand("SP_HOR_ConsultarHorarioDisActivo", _conexion);
consultar.CommandType = CommandType.StoredProcedure;
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = consultar.ExecuteReader();
reader.Read();
resultado = reader.GetInt32(0);
_conexion.Close();
return(resultado);
}
catch (Exception ex) // Si algo falla se reporta el error en la Bitácora de Errores del sistema
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(-1);
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que borra un turno
/// </summary>
/// <param name="idTurno">Id del turno a borrar</param>
/// <returns>Retorno una valor booleano indicando el éxito (true) o fracaso (false)</returns>
public Boolean borrarTurno(int idTurno)
{
Boolean resultado;
SqlCommand borrar = new SqlCommand("SP_HOR_BorrarTurno", _conexion);
borrar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[1];
parametros[0] = new SqlParameter("@idTurno", SqlDbType.Int);
parametros[0].Value = idTurno;
borrar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = borrar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
return(resultado);
}
catch (Exception ex) // Si algo falla se reporta el error en la Bitácora de Errores del sistema
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(false);
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que modifica un estado de laboratorio
/// </summary>
/// <param name="idEstado">id del estado a modificar</param>
/// <param name="descripcion">Descripción del estado</param>
/// <returns>Retorna un valor booleano que indica true si la inserción fue exitosa o false en caso contrario</returns>
public bool modificarEstadoLaboratorio(int idEstado, String descripcion)
{
Boolean resultado = false;
SqlCommand modificar = new SqlCommand("SP_PEUL_ModificarEstadoLaboratorio", _conexion);
modificar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[2];
parametros[0] = new SqlParameter("idEstadoLaboratorio", SqlDbType.Int);
parametros[0].Value = idEstado;
parametros[1] = new SqlParameter("@descripcion", SqlDbType.NText);
parametros[1].Value = descripcion;
modificar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = modificar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se encarga de obtener los estados en los que puede estar un laboratorio
/// </summary>
/// <returns>Lista de listas de objetos, la cual posee los PK del estado y la descripción de este</returns>
public List <List <object> > obtenerEstadoLaboratorio()
{
List <List <object> > resultado = new List <List <object> >();
List <object> nodo;
SqlCommand obtener = new SqlCommand("SP_PEUL_ObtenerEstadoLaboratorio", _conexion);
obtener.CommandType = CommandType.StoredProcedure;
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = obtener.ExecuteReader();
while (reader.Read())
{
nodo = new List <object>();
nodo.Add(reader.GetInt32(0)); // Obtener el ID
nodo.Add(reader.GetString(1)); // Obtener la descripción
resultado.Add(nodo);
}
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que deshabilita un horario de disponibilidad abierto
/// </summary>
/// <returns>Retorna un valor booleano indicando si la operación tuvo éxito (true) o no (false)</returns>
public Boolean deshabilitarHorarioDisponibilidad()
{
Boolean resultado;
SqlCommand actualizar = new SqlCommand("SP_HOR_DeshabilitarHorarioDisponibilidad", _conexion);
actualizar.CommandType = CommandType.StoredProcedure;
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = actualizar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
return(resultado);
}
catch (Exception ex) // Si algo falla se reporta el error en la Bitácora de Errores del sistema
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(false);
}
}
/// <summary>
/// Constructor de la clase ManejoBD
/// Este constructor indica los terminos de la conexión con la Base da Datos
/// </summary>
public ManejoBDSGC()
{
ConnectionStringSettings _settings = ConfigurationManager.ConnectionStrings["ModulosTI"]; // Propiedas del string de conexión almacenado en el .config
_conexion = new SqlConnection(_settings.ConnectionString);
_conexionBD = new ManejoBD();
}
/// <summary>
/// Método que se utiliza para eliminar los turnos que ya tenga un usuario en el horario, esto para que no haya choque con los nuevos que va a ingresar
/// </summary>
/// <param name="idHorario">PK del horario de disponibilidad</param>
/// <param name="login">Login del usuario al que se le van a eliminar los turnos</param>
public void eliminarTurnosDisponibilidad(int idHorario, string login)
{
SqlCommand insertar = new SqlCommand("SP_HOR_EliminarTurnosDisponibilidad", _conexion);
insertar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[2];
parametros[0] = new SqlParameter("@idhorario", SqlDbType.Int);
parametros[0].Value = idHorario;
parametros[1] = new SqlParameter("@login", SqlDbType.VarChar);
parametros[1].Value = login;
insertar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = insertar.ExecuteReader();
reader.Read();
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
}
/// <summary>
/// Método que se encarga de obtener el PK del horario de disponibilidad del semestre actual una vez deshabilitado el mismo
/// </summary>
/// <returns>Retorna un valor entero con el valor del PK o -1 en caso de error</returns>
public int consultarHorarioDisDeshabilitado()
{
int resultado = 0;
SqlCommand obtener = new SqlCommand("SP_HOR_ConsultarHorarioDisponiblidadActual", _conexion);
obtener.CommandType = CommandType.StoredProcedure;
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = obtener.ExecuteReader();
reader.Read();
resultado = reader.GetInt32(0);
_conexion.Close();
return(resultado);
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(-1);
}
}
/// <summary>
/// Método que se utiliza para consultar movimiento de activos por codigo y fecha
/// </summary>
/// <param name="codigo">string de codigo a consultar</param>
/// <param name="fecha">DateTime de fecha a consultar</param>
/// <returns>Una lista de listas de objetos, la cual contiene (codigo de activo, nombre de activo, tipo de movimiento
/// postby del movimiento, solicitante del movimiento, comentario del movimiento y fecha del movimiento) </returns>
public List <List <object> > consultarActivoPorCodigo2(string codigo)
{
List <List <object> > resultado = new List <List <object> >();
List <object> nodo;
SqlCommand obtener = new SqlCommand("SP_ACT_ConsultarActivoPorCodigo", _conexion);
obtener.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[1];
parametros[0] = new SqlParameter("@codigo", SqlDbType.VarChar);
parametros[0].Value = codigo;
obtener.Parameters.AddRange(parametros);
//DataTable _tablaReportes;
//_tablaReportes = new DataTable("Datos");
////_tablaReportes.Columns.Add(new DataColumn("Id Activo"));
//_tablaReportes.Columns.Add(new DataColumn("Codigo"));
//_tablaReportes.Columns.Add(new DataColumn("Nombre"));
//_tablaReportes.Columns.Add(new DataColumn("Tipo movimiento"));
//_tablaReportes.Columns.Add(new DataColumn("PostBy"));
//_tablaReportes.Columns.Add(new DataColumn("Solicitante"));
//_tablaReportes.Columns.Add(new DataColumn("Comentario"));
//_tablaReportes.Columns.Add(new DataColumn("Fecha"));
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = obtener.ExecuteReader();
while (reader.Read())
{
nodo = new List <object>();
nodo.Add(reader.GetString(0)); // Obtener el codigo de activo
nodo.Add(reader.GetString(1)); // Obtener el nombre del activo
nodo.Add(reader.GetString(2)); // Obtener el tipo de movimiento del activo
nodo.Add(reader.GetString(3)); // Obtener el postby del movimiento
nodo.Add(reader.GetString(4)); // Obtener el solicitante del movimiento
nodo.Add(reader.GetString(5)); // Obtener el comentario del movimiento
nodo.Add(reader.GetString(6)); // Obtener la fecha del movimiento
nodo.Add(reader.GetInt32(7)); // Obtener id de activo
nodo.Add(reader.GetInt32(8)); //Obtener estado de activo
resultado.Add(nodo);
//_tablaReportes.Rows.Add(reader.GetSqlString(0), reader.GetSqlString(1), reader.GetSqlString(2), reader.GetSqlString(3), reader.GetSqlString(4), reader.GetString(5), reader.GetString(6));
}
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se encarga de obtener el porcentaje de uso de actual de cada laboratorio y registrar un uso de laboratorio
/// </summary>
/// /// <param name="lugar">Objeto Registro que indica los datos del registro</param>
/// <returns>Lista de objetos que contiene sublistas con la información de uso de cada laboratorio
/// (Laboratorio-Operador-Fecha última actualización-Cantidad de usuarios-Cantidad de portatiles-Porcentaje de uso</returns
public List <List <object> > registrarPeul(Registro registro)
{
List <List <object> > resultado = new List <List <object> >();
List <object> nodo;
SqlCommand insertar = new SqlCommand("SP_PEUL_IngresarRegistroUtilizacion", _conexion);
insertar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[6];
parametros[0] = new SqlParameter("@idLugar", SqlDbType.Int);
parametros[0].Value = registro.IdLugar;
parametros[1] = new SqlParameter("@idEstadoLaboratorio", SqlDbType.Int);
parametros[1].Value = registro.IdEstadoLaboratorio;
parametros[2] = new SqlParameter("@cantUsuarios", SqlDbType.Int);
parametros[2].Value = registro.CantidadUsuarios;
parametros[3] = new SqlParameter("@cantPortatiles", SqlDbType.Int);
parametros[3].Value = registro.CantidadPortatiles;
parametros[4] = new SqlParameter("@comentario", SqlDbType.NText);
parametros[4].Value = registro.Comentario;
parametros[5] = new SqlParameter("@login", SqlDbType.VarChar);
parametros[5].Value = registro.Login;
insertar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = insertar.ExecuteReader();
while (reader.Read())
{
nodo = new List <object>();
nodo.Add(reader.GetString(0)); // Nombre del Laboratorio
nodo.Add(reader.GetString(1)); // Operador
nodo.Add(reader.GetDateTime(2)); // Fecha última actualización
nodo.Add(reader.GetString(3)); // Comentario
nodo.Add(reader.GetInt32(4)); // Cantidad de usuarios
nodo.Add(reader.GetInt32(5)); // Cantidad de portatiles
nodo.Add(reader.GetDecimal(6)); // Porcentaje de uso
resultado.Add(nodo);
}
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
resultado = null;
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se utiliza para consultar movimiento de activos por estado (prestado, devuelto)
/// </summary>
/// <param name="estado">int del estado a consultar</param>
/// <returns>Una lista de listas de objetos, la cual contiene (tipo de movimiento, id del activo, codigo del activo,
/// nombre del activo, fecha del movimiento, solicitante del movimiento, postby del movimiento) </returns>
public DataTable consultarActivoPorEstado(int estado)
{
//List<List<object>> resultado = new List<List<object>>();
//List<object> nodo;
SqlCommand obtener = new SqlCommand("SP_ACT_ConsultarActivoPorEstado", _conexion);
obtener.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[1];
parametros[0] = new SqlParameter("@estado", SqlDbType.Int);
parametros[0].Value = estado;
obtener.Parameters.AddRange(parametros);
DataTable _tablaReportes;
_tablaReportes = new DataTable("Datos");
//_tablaReportes.Columns.Add(new DataColumn("Id Activo"));
_tablaReportes.Columns.Add(new DataColumn("Tipo Movimiento"));
_tablaReportes.Columns.Add(new DataColumn("Codigo activo"));
_tablaReportes.Columns.Add(new DataColumn("Descripcion"));
_tablaReportes.Columns.Add(new DataColumn("Fecha"));
_tablaReportes.Columns.Add(new DataColumn("Solicitante"));
_tablaReportes.Columns.Add(new DataColumn("PostBy"));
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = obtener.ExecuteReader();
while (reader.Read())
{
//nodo = new List<object>();
//nodo.Add(reader.GetString(0)); // Obtener el tipo de movimiento
//nodo.Add(reader.GetInt16(1)); // Obtener el id de activo
//nodo.Add(reader.GetString(2)); // Obtener el codigo de activo
//nodo.Add(reader.GetString(3)); // Obtener la descripcion del activo
//nodo.Add(reader.GetDateTime(4)); // Obtener el fecha del movimiento
//nodo.Add(reader.GetString(5)); // Obtener el solicitante del movimiento
//nodo.Add(reader.GetString(6)); // Obtener el postBy del movimiento
//resultado.Add(nodo);
_tablaReportes.Rows.Add(reader.GetSqlString(0), reader.GetSqlString(1), reader.GetSqlString(2), reader.GetString(3), reader.GetString(4), reader.GetString(5));
}
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(_tablaReportes);
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que consulta los eventos de la bitácora en una fecha
/// </summary>
/// <param name="idSesion">Sesion en donde se registraron los eventos</param>
/// <returns>Retorna una DataTable con las entradas registradas en la bitácora en una sesion activa</returns>
public DataTable ConsultarEntradaPorSesion(int idSesion, int idLugar)
{
var tablaEventos = new DataTable();
tablaEventos.Columns.Add("PK_Entrada");
tablaEventos.Columns.Add("Fecha");
tablaEventos.Columns.Add("Operador");
tablaEventos.Columns.Add("Evento");
var consultar = new SqlCommand("SP_BIT_ConsultarEntradaPorSesion", _conexion)
{
CommandType = CommandType.StoredProcedure
};
var parametros = new SqlParameter[2];
parametros[0] = new SqlParameter("@idSesion", SqlDbType.Int)
{
Value = idSesion
};
parametros[1] = new SqlParameter("@idLugar", SqlDbType.Int)
{
Value = idLugar
};
consultar.Parameters.AddRange(parametros);
try
{
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
SqlDataReader reader = consultar.ExecuteReader();
while (reader.Read()) //Obtiene todos lo eventos, resultado de la busqueda
{
tablaEventos.Rows.Add(reader.GetInt32(0), reader.GetDateTime(1), reader.GetString(2), reader.GetString(3));
}
_conexion.Close();
return(tablaEventos);
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que retorna el porcentaje de uso de
/// un laboratorio en semestres en un rango de fechas
/// </summary>
/// <param name="pkLugar">Identificador del lugar sobrel el cual se realizará la búsqueda</param>
/// <param name="fechaInicio">Fecha de inicio del rango para la búsqueda</param>
/// <param name="fechaFinal">Fecha final del rango para la búsqueda</param>
/// <returns>Retorna un DataTable con los reportes de uso encontrados</returns>
public DataTable consultarPorcentajeUsoSemestres(int pkLugar, string fechaInicio, string fechaFinal)
{
SqlCommand consultar = new SqlCommand("SP_PEUL_CalcularUsoEnSemestre", _conexion);
consultar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[3];
parametros[0] = new SqlParameter("@fechaInicio", SqlDbType.Date);
parametros[0].Value = fechaInicio;
parametros[1] = new SqlParameter("@fechaFinal", SqlDbType.Date);
parametros[1].Value = fechaFinal;
parametros[2] = new SqlParameter("@lugar", SqlDbType.Int);
parametros[2].Value = pkLugar;
consultar.Parameters.AddRange(parametros);
DataTable _tablaReportes;
_tablaReportes = new DataTable("Datos");
_tablaReportes.Columns.Add(new DataColumn("Periodos"));
_tablaReportes.Columns.Add(new DataColumn("Usos"));
_tablaReportes.Columns.Add(new DataColumn("Laptops"));
try
{
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
SqlDataReader reader = consultar.ExecuteReader();
while (reader.Read()) // Obtener todos los lugares del sistema
{
_tablaReportes.Rows.Add(reader.GetString(0), reader.GetDecimal(1), reader.GetDecimal(2));
}
_conexion.Close();
return(_tablaReportes);
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que retorna los reportes de registros de uso hechos en el laboratorio especificado según el rango
/// </summary>
/// <param name="pkLugar">Identificador del lugar sobrel el cual se realizará la búsqueda</param>
/// <param name="fechaInicio">Fecha de inicio del rango para la búsqueda</param>
/// <param name="fechaFinal">Fecha final del rango para la búsqueda</param>
/// <returns>Retorna un DataTable con los reportes de uso encontrados</returns>
public DataTable consultarRegistroUso(int pkLugar, string fechaInicio, string fechaFinal)
{
SqlCommand consultar = new SqlCommand("SP_PEUL_ConsultarReportesUso", _conexion);
consultar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[3];
parametros[0] = new SqlParameter("@fkHistorialLugar", SqlDbType.Int);
parametros[0].Value = pkLugar;
parametros[1] = new SqlParameter("@fechaInicio", SqlDbType.Date);
parametros[1].Value = fechaInicio;
parametros[2] = new SqlParameter("@fechaFinal", SqlDbType.Date);
parametros[2].Value = fechaFinal;
consultar.Parameters.AddRange(parametros);
DataTable _tablaReportes;
_tablaReportes = new DataTable("Datos");
_tablaReportes.Columns.Add(new DataColumn("Fecha"));
_tablaReportes.Columns.Add(new DataColumn("Estado"));
_tablaReportes.Columns.Add(new DataColumn("Operador"));
_tablaReportes.Columns.Add(new DataColumn("Porcentaje"));
_tablaReportes.Columns.Add(new DataColumn("Usuarios"));
_tablaReportes.Columns.Add(new DataColumn("Portatiles"));
_tablaReportes.Columns.Add(new DataColumn("Comentario"));
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = consultar.ExecuteReader();
while (reader.Read()) // Obtener todos los lugares del sistema
{
_tablaReportes.Rows.Add(reader.GetDateTime(0), reader.GetString(1), reader.GetString(2), Convert.ToInt32(reader.GetDecimal(3)), reader.GetInt32(4), reader.GetInt32(5), reader.GetString(6));
}
_conexion.Close();
return(_tablaReportes);
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
/// <summary>
/// Método que se encarga de debolver todos los turnos existen en un horario de disponibilidad
/// </summary>
/// <param name="idHorario">PK del horario de disponibilidad</param>
/// <returns>Lista de listas de objetos, la listas contienen (PKTurnoDisponibilidad, FKHorarioDisponibilidad, Dia, HoraInicio, HorarioFinal, Nombre, Login)</returns>
public List <List <object> > obtenerTurnosDisponibilidad(int idHorario)
{
List <List <object> > resultado = new List <List <object> >();
List <object> nodo;
char[] dia; // Arreglo de chars para obtener el dia en que se encuentra el turno
SqlCommand obtener = new SqlCommand("SP_HOR_ObtenerTurnosDisponibilidad", _conexion);
obtener.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[1];
parametros[0] = new SqlParameter("@idhorario", SqlDbType.Int);
parametros[0].Value = idHorario;
obtener.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = obtener.ExecuteReader();
while (reader.Read())
{
nodo = new List <object>();
//nodo.Add(reader.GetInt32(0)); // PK del turno de disponibilidad
//nodo.Add(reader.GetInt32(1)); // FK del horario de disponibilidad
dia = reader.GetSqlChars(2).Value; // Char del dia
nodo.Add(dia[0]);
nodo.Add(reader.GetTimeSpan(3)); // Hora inicio
//nodo.Add(reader.GetTimeSpan(4)); // Hora final
nodo.Add(reader.GetString(5)); // Nombre
nodo.Add(reader.GetString(6)); // Login
resultado.Add(nodo);
}
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
resultado = null;
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que obtiene los turnos correspondientes a un horario de un semestre dado
/// </summary>
/// <param name="idSemestre">Id del semestre a buscar un horario</param>
/// <param name="idLugar">Id del lugar que se quiere ver su horario</param>
/// <returns>Retorna una lista de objetos Turno</returns>
public List <Turno> obtenerTurnosHorarios(int idSemestre, int idLugar)
{
List <Turno> resultado = new List <Turno>();
Turno turno;
SqlCommand consultar = new SqlCommand("SP_HOR_ConsultarTurnos", _conexion);
consultar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[2];
parametros[0] = new SqlParameter("@idSemestre", SqlDbType.Int);
parametros[0].Value = idSemestre;
parametros[1] = new SqlParameter("@idLugar", SqlDbType.Int);
parametros[1].Value = idLugar;
consultar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = consultar.ExecuteReader();
while (reader.Read())
{
turno = new Turno();
turno.IdTurno = reader.GetInt32(0);
turno.Dia = reader.GetSqlChars(1).Value[0];
turno.HoraInicio = Convert.ToDateTime(reader.GetTimeSpan(2).ToString());
turno.HoraFinal = Convert.ToDateTime(reader.GetTimeSpan(3).ToString());
turno.NombrePersona = reader.GetString(4);
resultado.Add(turno);
}
_conexion.Close();
return(resultado);
}
catch (Exception ex) // Si algo falla se reporta el error en la Bitácora de Errores del sistema
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
/// <summary>
/// Método que se encarga de insertar un turno de disponibilidad
/// </summary>
/// <param name="nuevoTurno">Turno que se va a insertar</param>
/// <param name="login">Login del operador que registro el turno</param>
/// <returns>Retorna true si se inserto con exito, de lo contrario retorna false</returns>
public Boolean insertarTurnoDisponibilidad(List <object> turno)
{
Boolean resultado = false;
SqlCommand insertar = new SqlCommand("SP_HOR_InsertarTurnoDisponibilidad", _conexion);
insertar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[6];
parametros[0] = new SqlParameter("@idhorario", SqlDbType.Int);
parametros[0].Value = Convert.ToInt32(turno[0]);
parametros[1] = new SqlParameter("@dia", SqlDbType.Char);
parametros[1].Value = Convert.ToChar(turno[1]);
parametros[2] = new SqlParameter("@horaInicio", SqlDbType.Time);
parametros[2].Value = TimeSpan.Parse(turno[2].ToString());
parametros[3] = new SqlParameter("@horaFinal", SqlDbType.Time);
parametros[3].Value = TimeSpan.Parse(turno[3].ToString());
parametros[4] = new SqlParameter("@nombre", SqlDbType.NText);
parametros[4].Value = turno[4].ToString();
parametros[5] = new SqlParameter("@login", SqlDbType.VarChar);
parametros[5].Value = turno[5].ToString();
insertar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = insertar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que inserta un nuevo turno en el sistema
/// </summary>
/// <param name="nuevoTurno">Objeto Turno que contiene la información del turno nuevo</param>
/// <returns>Retorna un valor booleano indicando si la operación tuvo éxito (true) o no (false)</returns>
public Boolean insertarTurno(Turno nuevoTurno)
{
Boolean resultado;
SqlCommand insertar = new SqlCommand("SP_HOR_InsertarTurno", _conexion);
insertar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[5];
parametros[0] = new SqlParameter("@idHorario", SqlDbType.Int);
parametros[0].Value = nuevoTurno.IdHorario;
parametros[1] = new SqlParameter("@dia", SqlDbType.Char);
parametros[1].Value = nuevoTurno.Dia;
parametros[2] = new SqlParameter("@horaInicio", SqlDbType.Time);
parametros[2].Value = String.Format("{0:HH:mm:ss}", nuevoTurno.HoraInicio);
parametros[3] = new SqlParameter("@horaFinal", SqlDbType.Time);
parametros[3].Value = String.Format("{0:HH:mm:ss}", nuevoTurno.HoraFinal);
parametros[4] = new SqlParameter("@nombre", SqlDbType.NText);
parametros[4].Value = nuevoTurno.NombrePersona;
insertar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = insertar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
return(resultado);
}
catch (Exception ex) // Si algo falla se reporta el error en la Bitácora de Errores del sistema
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
return(false);
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que modifica un periodo lectivo en el sistema
/// </summary>
/// <param name="semestre">Objeto semestre</param>
/// <returns>Retorna una valor booleano indicando si tuvo éxito (true) o no (false)</returns>
public bool modificarSemestre(Semestre semestre)
{
Boolean resultado = false;
SqlCommand modificar = new SqlCommand("SP_SIS_ModificarSemestre", _conexion);
modificar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[5];
parametros[0] = new SqlParameter("@id", SqlDbType.Int);
parametros[0].Value = semestre.IdSemestre;
parametros[1] = new SqlParameter("@nombre", SqlDbType.VarChar);
parametros[1].Value = semestre.NombreSemestre;
parametros[2] = new SqlParameter("@fechaInicio", SqlDbType.Date);
parametros[2].Value = semestre.FechaInicio;
parametros[3] = new SqlParameter("@fechaFinal", SqlDbType.Date);
parametros[3].Value = semestre.FechaFinal;
parametros[4] = new SqlParameter("@activo", SqlDbType.Bit);
parametros[4].Value = semestre.Activo;
modificar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = modificar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se utiliza para obtener los datos del uso de los laboratorios
/// </summary>
/// <returns>Una lista de listas de objetos, la cual contiene (nombre del laboratorio, login del operador, fecha de ultima actualización, comentario,
/// cantidad de usuarios, cantidad de laptops) </returns>
public List <List <object> > calcularUsoActual()
{
List <List <object> > resultado = new List <List <object> >();
List <object> nodo;
SqlCommand obtener = new SqlCommand("SP_PEUL_CalcularUsoActualEnTodoLaboratorio", _conexion);
obtener.CommandType = CommandType.StoredProcedure;
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = obtener.ExecuteReader();
while (reader.Read())
{
nodo = new List <object>();
nodo.Add(reader.GetString(0)); // Obtener el nombre del Laboratorio
nodo.Add(reader.GetString(1)); // Obtener el login del operador
nodo.Add(reader.GetDateTime(2)); // Obtener fecha de ultima actualización
nodo.Add(reader.GetString(3)); // Obtener el comentario
nodo.Add(reader.GetInt32(4)); // Obtener la cantidad de usuarios
nodo.Add(reader.GetInt32(5)); // Obtener la cantidad de laptops
nodo.Add(reader.GetDecimal(6)); // Obtener el porcentaje de uso
resultado.Add(nodo);
}
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que modifica un activo en el sistema
/// </summary>
/// <param name="activo">Objeto activo</param>
/// <returns>Retorna una valor booleano indicando si tuvo éxito (true) o no (false)</returns>
public bool modificarActivo(Activo activo)
{
Boolean resultado = false;
SqlCommand modificar = new SqlCommand("SP_ACT_ModificarActivo", _conexion);
modificar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[3];
parametros[0] = new SqlParameter("@PK_Activo", SqlDbType.Int);
parametros[0].Value = activo.IdActivo;
parametros[1] = new SqlParameter("@descripcion", SqlDbType.VarChar);
parametros[1].Value = activo.Descripcion;
parametros[2] = new SqlParameter("@estado", SqlDbType.Bit);
parametros[2].Value = activo.EstadoActivo;
modificar.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = modificar.ExecuteReader();
reader.Read();
resultado = !(reader.HasRows);
_conexion.Close();
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_BDCompartido = new ManejoBD();
_BDCompartido.insertarBitacoraError(ex.ToString(), "");
}
return(resultado);
}
public ControladorBitacora()
{
_conexionBD = new ManejoBD();
_conexionBitacoraBD = new ManejoBDBitacora();
}
public ControladorActivo()
{
_conexionBD = new ManejoBD();
_conexionActivoBD = new ManejoBDActivo();
_conexionLDAP = new ConexionLDAP();
}
public ControladorHorario()
{
_conexionBDHorario = new ManejoBDHorario();
_conexionBD = new ManejoBD();
}
/***********************************/
/// <summary>
/// Método que se encarga de buscar las reservaciones en un periodo especifico
/// </summary>
/// <param name="idLugar">Id del laboratorio que se desea consultar</param>
/// <param name="fechaInicio">Fecha de Inicio del periodo a consultar</param>
/// <param name="fechaFin">Fecha Fin del periodo a consultar</param>
/// <returns>Retorna un arreglo de arreglos de string con las reservaciones realizadas en ese periodo</returns>
public DataTable consultarReservacion(string idLugar, string fechaInicio, string fechaFin)
{
SqlCommand consultar = new SqlCommand("SP_RES_ConsultarHorarioReservacion", _conexion);
consultar.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[3];
parametros[0] = new SqlParameter("@idLugar", SqlDbType.Int);
parametros[0].Value = idLugar;
parametros[1] = new SqlParameter("@fechaInicio", SqlDbType.Date);
parametros[1].Value = fechaInicio;
parametros[2] = new SqlParameter("@fechaFin", SqlDbType.Date);
parametros[2].Value = fechaFin;
consultar.Parameters.AddRange(parametros);
DataTable _tablaReportes;
_tablaReportes = new DataTable("Datos");
_tablaReportes.Columns.Add(new DataColumn("Dias"));
_tablaReportes.Columns.Add(new DataColumn("Hora Inicio"));
_tablaReportes.Columns.Add(new DataColumn("Hora Final"));
_tablaReportes.Columns.Add(new DataColumn("Fecha Inicio"));
_tablaReportes.Columns.Add(new DataColumn("Fecha Final"));
_tablaReportes.Columns.Add(new DataColumn("Solicitante"));
_tablaReportes.Columns.Add(new DataColumn("Curso"));
_tablaReportes.Columns.Add(new DataColumn("Descripcion"));
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = consultar.ExecuteReader();
string dias = "";
int idReserv = 0; //guarda el id de la reservacion
List <List <object> > reservaciones = new List <List <object> >();
List <object> reserva;
while (reader.Read()) // Obtener todos los lugares del sistema
{
reserva = new List <object>();
reserva.Add(reader.GetInt32(0));
reserva.Add(reader.GetString(1));
reserva.Add(reader.GetString(2));
reserva.Add(reader.GetString(3));
reserva.Add(reader.GetString(4));
reserva.Add(reader.GetString(5));
reserva.Add(reader.GetString(6));
reserva.Add(reader.GetString(7));
reserva.Add(reader.GetString(8));
reservaciones.Add(reserva);
}
idReserv = (int)reservaciones.ElementAt(0).ElementAt(0);
int i = 0;
for (i = 0; i < reservaciones.Count; i++)
{
if ((!(idReserv == (int)reservaciones.ElementAt(i).ElementAt(0))))
{
_tablaReportes.Rows.Add(dias, (string)reservaciones.ElementAt(i - 1).ElementAt(1), (string)reservaciones.ElementAt(i - 1).ElementAt(2), (string)reservaciones.ElementAt(i - 1).ElementAt(3), (string)reservaciones.ElementAt(i - 1).ElementAt(4), (string)reservaciones.ElementAt(i - 1).ElementAt(5), (string)reservaciones.ElementAt(i - 1).ElementAt(6), (string)reservaciones.ElementAt(i - 1).ElementAt(7));//, dias);
dias = "";
dias += (String)reservaciones.ElementAt(i).ElementAt(8) + ",";
}
else
{
dias += (String)reservaciones.ElementAt(i).ElementAt(8) + ",";
}
idReserv = (int)reservaciones.ElementAt(i).ElementAt(0);
}
i = reservaciones.Count - 1;
_tablaReportes.Rows.Add(dias, (string)reservaciones.ElementAt(i).ElementAt(1), (string)reservaciones.ElementAt(i).ElementAt(2), (string)reservaciones.ElementAt(i).ElementAt(3), (string)reservaciones.ElementAt(i).ElementAt(4), (string)reservaciones.ElementAt(i).ElementAt(5), (string)reservaciones.ElementAt(i).ElementAt(6), (string)reservaciones.ElementAt(i).ElementAt(7));//, dias);
_conexion.Close();
return(_tablaReportes);
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_conexionCompartido = new ManejoBD();
_conexionCompartido.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
public ControladorPEUL()
{
_conexionBD = new ManejoBD();
_conexionLDAP = new ConexionLDAP();
_conexionPEULBD = new ManejoBDPEUL();
}
public ControladorReservacionCR()
{
_conexionBD = new ManejoBD();
_reservacionBD = new ManejoBDReservacion();
_conexionLDAP = new ConexionLDAP();
}
