/// <summary>
/// Método que se encarga de obtener todos los laboratorios existentes
/// </summary>
/// <returns>Retorna una lista de listas de objetos, en donde cada sublista es un lugar de la forma List(List(IdLugar:int, NombreLugar:String
/// Capacidad:int, Descripcion:String, Encargado:String, Tipo:Boolean)). En caso de fallo retorna null</returns>
public List <List <object> > obtenerLaboratorios()
{
try
{
List <Lugar> lugar = _conexionBD.consultarLugares();
if ((lugar != null) && (lugar.Count != 0))
{
List <object> nodo = new List <object>();
List <List <object> > lugares = new List <List <object> >();
for (int i = 0; i < lugar.Count; i++)
{
if (lugar.ElementAt(i).NombreTipoLugar.Equals("Laboratorio"))
{
nodo.Add(lugar.ElementAt(i).IdLugar);
nodo.Add(lugar.ElementAt(i).NombreLugar);
nodo.Add(lugar.ElementAt(i).Capacidad);
nodo.Add(lugar.ElementAt(i).Descripcion);
nodo.Add(lugar.ElementAt(i).Encargado);
lugares.Add(nodo);
nodo = new List <object>();
}
}
return(lugares);
} // Luego agregar reporte de error sino se encuentran lugares
else
{
return(null);
}
}
catch (Exception ex)
{
_conexionBD.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
/// <summary>
/// Método que se encarga de crear un nuevo usuario en la base de datos
/// </summary>
/// <param name="usuario">Objeto usuario</param>
/// <param name="imagen">Foto del usuario si es proporcionada</param>
/// <returns>Retorna un número entero (1: fue exitoso, 0: fallo, -1: error al intentar crearlo)</returns>
public int crearUsuario(Usuario usuario, byte[] imagen)
{
SqlCommand comando = new SqlCommand("SP_COM_InsertarUsuario", _conexion);
SqlParameter[] parametros = new SqlParameter[3];
comando.CommandType = CommandType.StoredProcedure;
parametros[0] = new SqlParameter("@login", SqlDbType.VarChar);
parametros[0].Value = usuario.UID;
parametros[1] = new SqlParameter("@Carrera", SqlDbType.VarChar);
parametros[1].Value = usuario.Carrera;
parametros[2] = new SqlParameter("@foto", SqlDbType.Image);
if (imagen != null)
{
parametros[2].Value = imagen;
}
else
{
parametros[2].Value = DBNull.Value;
}
comando.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = comando.ExecuteReader();
Boolean resultado = !(reader.HasRows);
if (resultado)
{
_conexion.Close();
return(1);
}
else
{
_conexion.Close();
return(0);
}
}
catch (Exception e)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_conexionBD.insertarBitacoraError(e.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 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 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 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 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 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>
/// 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 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 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 guardar los turnos de disponibilidad
/// </summary>
/// <param name="turnos">Lista de listas de objetos que contiene los turnos que se han ingresado</param>
/// <returns>Ture si se guardaron con exito, de lo contrario false</returns>
public Boolean insertarTurnosDisponibilidad(List <List <object> > turnos)
{
bool resultado = true;
try
{
// Eliminar los turnos de disponibilidad que el usuario pudiera tener antes
_conexionBDHorario.eliminarTurnosDisponibilidad(Convert.ToInt32(turnos[0][0]), Convert.ToString(turnos[0][5]));
//Insertar los turnos
foreach (List <object> turno in turnos)
{
resultado = resultado && _conexionBDHorario.insertarTurnoDisponibilidad(turno); //Inserta el turno y va verificando que se inserto bien
}
}
catch (Exception ex)
{
_conexionBD.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 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);
}
/// <summary>
/// Método que se encarga de obtener las entradas de errores que se han dado en la plataforma, pueden o no usarse filtros
/// </summary>
/// <param name="fechaInicio">Fecha inicio para buscar eventos</param>
/// <param name="fechaFinal">Fecha Final para buscar eventos</param>
/// <param name="estado">Estados de los filtros a buscar</param>
/// <returns>Retorna una lista de listas de objetos de la forma (PK_Error:int, Fecha:DateTime, DescripciónSis:string, DescripciónUs:string,
/// Estado:int)</returns>
public List <List <object> > obtenerEntradasBitError(string fechaInicio, string fechaFinal, int estado)
{
List <List <object> > resultado = new List <List <object> >();
List <object> nodo;
SqlCommand consulta = new SqlCommand("SP_SIS_ConsultarBitacoraError", _conexion);
consulta.CommandType = CommandType.StoredProcedure;
SqlParameter[] parametros = new SqlParameter[3];
parametros[0] = new SqlParameter("@fechaInicio", SqlDbType.Date);
parametros[1] = new SqlParameter("@fechaFinal", SqlDbType.Date);
parametros[2] = new SqlParameter("@estado", SqlDbType.Int);
if (!fechaInicio.Equals(""))
{
parametros[0].Value = fechaInicio;
parametros[1].Value = fechaFinal;
}
else
{
parametros[0].Value = DBNull.Value;
parametros[1].Value = DBNull.Value;
}
if (estado != -1)
{
parametros[2].Value = estado;
}
else
{
parametros[2].Value = DBNull.Value;
}
consulta.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = consulta.ExecuteReader();
while (reader.Read())
{
nodo = new List <object>();
nodo.Add(reader.GetInt32(0)); // Obtener el PK
nodo.Add(reader.GetDateTime(1)); // Obtener fecha del evento
nodo.Add(reader.GetString(2)); // Obtener descripción del sistema del error
nodo.Add(reader.GetString(3)); // Obtener descripción del usuario del error
nodo.Add(Convert.ToInt32(reader.GetByte(4))); // Obtener el estado del error
resultado.Add(nodo);
}
_conexion.Close();
return(resultado);
}
catch (Exception ex)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
_conexionBD = new ManejoBD();
_conexionBD.insertarBitacoraError(ex.ToString(), "");
return(null);
}
}
/***********************************/
/// <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);
}
}
/// <summary>
/// Método que se encarga de llamar al stored procedure que inserta una reservación, una vez verificado que no haya choques
/// </summary>
/// <param name="reservacion">Objeto reservación</param>
/// <param name="usuario">Usuario que esta logueado en el sistema</param>
/// <param name="horario">Valor booleano que indica si esta reservación también se toma en cuenta para los Horario</param>
/// <returns>Retorna null si tuvo éxito. Si existen choques retorna una lista con la información de los choques encontrados.
/// En caso de error en el primer elemento podría tener una de las siguientes cadenas de caracteres: Error 1 (se dio una excepción
/// al buscar choques con la reservación que se quiere insertar), Error 2 (se dio una excepción al insertar la reservación),
/// Error 3 (se dio un error al insertar una asignación) o Error 4 (se dio una excepción al insertar una asignación).</returns>
public List <List <object> > insertarReservacion(Reservacion reservacion, string usuario, Boolean horario)
{
int idReservacion = -1; // PK de la reservación que será registrada
List <List <object> > choques = new List <List <object> >(); // Lista donde se guardan todos los choques encontrados
List <object> choque; // Sublista que contiene un choque, se guardará en la lista anterior
SqlCommand comando = new SqlCommand("SP_RES_VerificarChoques", _conexion);
SqlParameter[] parametros;
comando.CommandType = CommandType.StoredProcedure;
for (int i = 0; i < reservacion.Dia.Count; i++) // Verificar que no hay choques en todos los días especificados por el solicitante
{
comando.Parameters.Clear();
parametros = new SqlParameter[6];
parametros[0] = new SqlParameter("@dia", SqlDbType.Char);
parametros[0].Value = reservacion.Dia.ElementAt(i);
parametros[1] = new SqlParameter("@horaInicio", SqlDbType.Time);
parametros[1].Value = String.Format("{0:HH:mm:ss}", reservacion.HoraInicio);
parametros[2] = new SqlParameter("@horaFinal", SqlDbType.Time);
parametros[2].Value = String.Format("{0:HH:mm:ss}", reservacion.HoraFinal);
parametros[3] = new SqlParameter("@fechaInicio", SqlDbType.Date);
parametros[3].Value = reservacion.FechaInicio;
parametros[4] = new SqlParameter("@fechaFinal", SqlDbType.Date);
parametros[4].Value = reservacion.FechaFinal;
parametros[5] = new SqlParameter("@idLugar", SqlDbType.Int);
parametros[5].Value = reservacion.IdLugar;
comando.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = comando.ExecuteReader();
int reservacionActual = 0; // Obtener el id de la reservación que se esta buscando actualmente (para choques)
bool reservacionExiste; // Para saber si ya ha sido insertada
while (reader.Read())
{
if (reader.GetInt32(0) != 1) // Si encuentra choques los guarda en la lista
{
choque = new List <object>();
reservacionActual = reader.GetInt32(1); // Identificador de la reservación (para no llenar con repetidos)
reservacionExiste = true;
for (int j = 0; j < choques.Count; j++) // Verificar que el la reservación ya no haya sido reportada
{
if (Convert.ToInt32(choques.ElementAt(j).ElementAt(5)) == reservacionActual)
{
reservacionExiste = false;
break;
}
}
if (reservacionExiste)
{
choque.Add(reader.GetDateTime(2)); // Fecha Inicio
choque.Add(reader.GetDateTime(3)); // Fecha Final
choque.Add(reader.GetTimeSpan(4)); // Hora Inicio
choque.Add(reader.GetTimeSpan(5)); // Hora Final
choque.Add(reader.GetString(6)); // Nombre del solicitante con el cual presenta choque
choque.Add(reservacionActual); // PK de la reservación con la que tiene choque
choques.Add(choque); // Agregar el choque a la lista de choques encontrados
}
}
else
{
break;
}
}
_conexion.Close();
}
catch (Exception e)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
choques = new List <List <object> >();
choque = new List <object>();
choque.Add("Error 1");
choques.Add(choque);
_conexionCompartido.insertarBitacoraError(e.ToString(), "");
return(choques); // Reportar que hubo una excepción al buscar choques de la reservación
}
}
if (choques.Count < 1) // Insertar la reservacíón una vez verificado que no hay choques
{
comando = new SqlCommand("SP_RES_InsertarReservacion", _conexion);
comando.CommandType = CommandType.StoredProcedure;
parametros = new SqlParameter[8];
parametros[0] = new SqlParameter("@fechaInicio", SqlDbType.Date);
parametros[0].Value = reservacion.FechaInicio;
parametros[1] = new SqlParameter("@fechaFinal", SqlDbType.Date);
parametros[1].Value = reservacion.FechaFinal;
parametros[2] = new SqlParameter("@idLugar", SqlDbType.Int);
parametros[2].Value = reservacion.IdLugar;
parametros[3] = new SqlParameter("@idCurso", SqlDbType.Int);
parametros[3].Value = reservacion.IdCurso;
parametros[4] = new SqlParameter("@solicitante", SqlDbType.NVarChar);
parametros[4].Value = reservacion.Solicitante;
parametros[5] = new SqlParameter("@solicitanteID", SqlDbType.VarChar);
parametros[5].Value = reservacion.LoginSolicitante;
parametros[6] = new SqlParameter("@descripcion", SqlDbType.NText);
parametros[6].Value = reservacion.Descripcion;
parametros[7] = new SqlParameter("@postBy", SqlDbType.VarChar);
parametros[7].Value = usuario; // Usuario que esta logueado en el sistema y realiza la reservación
comando.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = comando.ExecuteReader();
reader.Read();
idReservacion = Convert.ToInt32(reader.GetDecimal(0)); // Obtiene el PK de la reservación recién insertada
_conexion.Close();
}
catch (Exception e)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
choques = new List <List <object> >();
choque = new List <object>();
choque.Add("Error 2");
choques.Add(choque);
_conexionCompartido.insertarBitacoraError(e.ToString(), "");
return(choques); // Reportar que hubo una excepción al insertar la reservación
}
if (idReservacion != -1) // Verificar que se haya obtenido el PK de la reservación
{
// Insertar las asignaciones
comando = new SqlCommand("SP_RES_InsertarAsignacion", _conexion);
comando.CommandType = CommandType.StoredProcedure;
for (int i = 0; i < reservacion.Dia.Count; i++) // Insertar las asignaciones para todos los días especificados
{
comando.Parameters.Clear();
parametros = new SqlParameter[5];
parametros[0] = new SqlParameter("@dia", SqlDbType.Char);
parametros[0].Value = reservacion.Dia.ElementAt(i);
parametros[1] = new SqlParameter("@idReservacion", SqlDbType.Int);
parametros[1].Value = idReservacion;
parametros[2] = new SqlParameter("@horaInicio", SqlDbType.Time);
parametros[2].Value = String.Format("{0:HH:mm:ss}", reservacion.HoraInicio);
parametros[3] = new SqlParameter("@horaFinal", SqlDbType.Time);
parametros[3].Value = String.Format("{0:HH:mm:ss}", reservacion.HoraFinal);
parametros[4] = new SqlParameter("@guardarHorario", SqlDbType.Bit);
parametros[4].Value = horario;
comando.Parameters.AddRange(parametros);
if (_conexion.State == ConnectionState.Closed)
{
_conexion.Open();
}
try
{
SqlDataReader reader = comando.ExecuteReader();
reader.Read();
if (reader.HasRows) // No se inserto la asignación
{
choques = new List <List <object> >();
choque = new List <object>();
choque.Add("Error 3");
choques.Add(choque);
return(choques); // Reportar que hubo un error al insertar una asignación
}
_conexion.Close();
}
catch (Exception e)
{
if (_conexion.State == ConnectionState.Open)
{
_conexion.Close();
}
choques = new List <List <object> >();
choque = new List <object>();
choque.Add("Error 4");
choques.Add(choque);
_conexionCompartido.insertarBitacoraError(e.ToString(), "");
return(choques); // Retornar que hubo una excepción al insertar una asignación
}
}
}
return(null); // Si tuvo éxito
}
else // Retorna los choques encontrados
{
return(choques);
}
}
/// <summary>
/// Método que se encarga de insertar los errores que se produscan en el sistema en la tabla BitacoraError
/// </summary>
/// <param name="descripcionSis">Descripción del error provista por el sistema</param>
/// <param name="descripcionUser">Descripción del error provista por el usuario</param>
public void insertarBitacoraError(string descripcionSis, string descripcionUser)
{
_conexionBD.insertarBitacoraError(descripcionSis, descripcionUser);
}