/*TODO:
* - int insertarProgreso(clsPruebasJugadores progreso)
* - ObservableCollection<clsPruebasJugadores> getProgresoJugador(idJugador)
*/
/// <summary>
/// Método que inserta un nuevo registro como progreso del jugador cada vez que este supera una prueba,
/// con el tiempo que ha tardado en superarla
/// </summary>
/// <param name="progreso">clsPruebasJugadores con los datos del progreso para una prueba en concreto</param>
/// <returns></returns>
public int insertarProgreso(clsPruebasJugadores progreso)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas;
TimeSpan timeSpan = new TimeSpan(progreso.TiempoJugador.Hour, progreso.TiempoJugador.Minute, progreso.TiempoJugador.Second);
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@idPrueba", System.Data.SqlDbType.Int).Value = progreso.IdPrueba;
command.Parameters.Add("@idJugador", System.Data.SqlDbType.Int).Value = progreso.IdJugador;
//command.Parameters.Add("@tiempoJugador", System.Data.SqlDbType.Time).Value = progreso.TiempoJugador;
command.Parameters.Add("@tiempoJugador", System.Data.SqlDbType.Time).Value = timeSpan; //Tiene queser TimeSpan porque es el correspondiente para tipo Time en BBDD
command.CommandText = "INSERT INTO CJ_PruebasJugadores(idJugador, idPrueba, tiemoJugador) VALUES (@idJugador, @idPrueba, @tiempoJugador)";
//Ejecuta la instrucción SQL
filasAfectadas = command.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
/*TODO:
* int insertarLuchadorCombate(clsLuchadorCombate nuevoLuchadorCombate)
* int actualizarPuntuacionLuchadorCombate(clsLuchadorcombate luchadorConNuevaPuntuacion)
*/
/// <summary>
/// Método que inserta un nuevo registro en tabla SH_LuchadoresCombates
/// </summary>
/// <param name="nuevoLuchadorCombate">clsLuchadorCombate, con los datos del objeto a insertar</param>
/// <returns>int filasAfectadas, con el número de filas afectadas por la sentencia</returns>
public int insertarLuchadorCombate(clsLuchadorCombate nuevoLuchadorCombate)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas;
//int idCombate = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@idCombate", System.Data.SqlDbType.Int).Value = nuevoLuchadorCombate.IdCombate;
command.Parameters.Add("@idLuchador", System.Data.SqlDbType.Int).Value = nuevoLuchadorCombate.IdLuchador;
command.Parameters.Add("@puntuacionLuchador", System.Data.SqlDbType.Int).Value = nuevoLuchadorCombate.PuntuacionLuchador;
command.CommandText = "INSERT INTO SH_LuchadoresCombates(idCombate, idLuchador, puntuacionLuchador) VALUES(@idCombate, @idLuchador, @puntuacionLuchador)";
//Ejecuta la instrucción SQL
filasAfectadas = command.ExecuteNonQuery();
//idCombate = (int)command.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
/// <summary>
/// Método que actualiza la puntuación de un lucchador en un combate
/// </summary>
/// <param name="nuevaPuntuacionLuchadorCombate">clsLuchadorCombate con los datos para actualizar el registro con la nueva puntuación</param>
/// <returns>int filasAfectadas, con número de filas afectadas por la ejecución</returns>
public int actualizarPuntuacionLuchadorCombate(clsLuchadorCombate nuevaPuntuacionLuchadorCombate)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas;
//int idCombate = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@idCombate", System.Data.SqlDbType.Int).Value = nuevaPuntuacionLuchadorCombate.IdCombate;
command.Parameters.Add("@idLuchador", System.Data.SqlDbType.Int).Value = nuevaPuntuacionLuchadorCombate.IdLuchador;
command.Parameters.Add("@puntuacionLuchador", System.Data.SqlDbType.Int).Value = nuevaPuntuacionLuchadorCombate.PuntuacionLuchador; //Nueva puntuación a añadir
command.CommandText = "UPDATE SH_LuchadoresCombates SET puntuacionLuchador = puntuacionLuchador + @puntuacionLuchador WHERE idLuchador = @idLuchador AND idCombate = @idCombate";
//Ejecuta la instrucción SQL
filasAfectadas = command.ExecuteNonQuery();
//idCombate = (int)command.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
public List <clsPersonaConNombreDeDepartamento> listadoCompletoPersonasConNombreDept()
{
clsPersonaConNombreDeDepartamento oPersona = new clsPersonaConNombreDeDepartamento();
SqlConnection miConexion;
List <clsPersonaConNombreDeDepartamento> ret = new List <clsPersonaConNombreDeDepartamento>();
SqlCommand miComando = new SqlCommand();
SqlDataReader miLector;
clsMyConnection connection = new clsMyConnection();
//Try no obligatorio ya que esta en clase myconnection
miConexion = connection.getConnection();
miComando.CommandText = "select IDPersona,Personas.IDDepartamento as iddep,nombrePersona,apellidosPersona,fechaNacimiento,telefono,direccion,nombreDepartamento from Personas inner join Departamentos on Personas.IDDepartamento = Departamentos.IDDepartamento";
miComando.Connection = miConexion;
miLector = miComando.ExecuteReader();
if (miLector.HasRows)
{
while (miLector.Read())
{
oPersona = new clsPersonaConNombreDeDepartamento();
oPersona.idPersona = (int)miLector["IDPersona"];
oPersona.IdDept = (int)miLector["iddep"];
oPersona.nombre = (String)miLector["nombrePersona"];
oPersona.Apellidos = (String)miLector["apellidosPersona"];
oPersona.fechaNacimiento = (DateTime)miLector["fechaNacimiento"];
oPersona.telefono = (String)miLector["telefono"];
oPersona.direccion = (string)miLector["direccion"];
oPersona.nombreDepartamento = (string)miLector["nombreDepartamento"];
ret.Add(oPersona);
}
}
miLector.Close();
connection.closeConnection(ref miConexion);
return(ret);
}
/// <summary>
/// Método que inserta una nueva palabra en la BBDD
/// </summary>
/// <param name="nuevaPalabra">clsPalabra con los datos de la nueva palabra</param>
/// <returns>int idPalabra, de la palabra insertada en la BBDD</returns>
public int insertarPalabra(clsPalabra nuevaPalabra)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
//int filasAfectadas;
Int32 idPalabra = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@palabra", System.Data.SqlDbType.VarChar).Value = nuevaPalabra.Palabra;
command.Parameters.Add("@dificultad", System.Data.SqlDbType.TinyInt).Value = nuevaPalabra.Dificultad;
/*Me llama la atención meter dos sentencias SQL a la vez en el CommandText, pero en la documentación de microsoft lo hacen así, con la sentencia de inserción primero y después
* el select, y obtiene el idJugador únicamente que era mi intención, porque es lo único que quiero pasarle a la siguiente vista*/
command.CommandText = "INSERT INTO CJ_Palabras(palabra, dificultad) VALUES (@palabra, @dificultad) " +
"SELECT * FROM CJ_Palabras WHERE palabra = @palabra"; //Pilla sólo la primera columna y de la primera fila de las afectadas por la sentencia, en mi caso el idPalabra
//Ejecuta la instrucción SQL
idPalabra = (Int32)command.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return((int)idPalabra);
}
/// <summary>
/// El método devuelve una lista de todas las personas de la base de datos, en caso
/// de que no haya filas en la consulta, la lista la devuelve vacía
/// </summary>
/// <returns>una lista de personas</returns>
public List <clsPersona> listadoCompletoPersonasDAL()
{
//Variables
List <clsPersona> listaPersonas = new List <clsPersona>();
SqlConnection miConexion;
SqlDataReader miLector;
SqlCommand miComando = new SqlCommand();
clsMyConnection gestoraConexion = new clsMyConnection();
clsPersona persona;
//Algoritmo
miConexion = gestoraConexion.getConnection(); //No es necesario poner try/catch porque myConnection ya lo gestiona
miComando.CommandText = "SELECT * FROM Personas";
miComando.Connection = miConexion;
miLector = miComando.ExecuteReader();
if (miLector.HasRows)
{
while (miLector.Read())
{
persona = new clsPersona();
persona.idPersona = (int)miLector["idPersona"];
persona.nombre = (String)miLector["nombrePersona"];
persona.apellidos = (String)miLector["apellidosPersona"];
persona.fechaNacimiento = (DateTime)miLector["fechaNacimiento"];
persona.telefono = (String)miLector["telefono"];
persona.direccion = (String)miLector["direccion"];
persona.idDepartamento = (int)miLector["idDepartamento"];
listaPersonas.Add(persona);
}
}
//Cerrar conexion
gestoraConexion.closeConnection(ref miConexion);
miLector.Close();
return(listaPersonas);
}
/// <summary>
/// Metodo que devuelve un listado con los nombres de los personajes
/// </summary>
/// <returns>listadoNombres</returns>
public List <clsPersonaje> ListadoNombresPersonajes()
{
//Declaraciones
clsPersonaje oPersonaje;
List <clsPersonaje> listadoNombres = new List <clsPersonaje>();
clsMyConnection miConexion = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand comando = new SqlCommand();
SqlDataReader lector = null;
//Abrimos una nueva conexion
sqlConnection = miConexion.getConnection();
//Creamos una nueva sentencia a traves del CommandText
comando.CommandText = "SELECT Nombre, idPersonaje FROM Personajes";
//Asignamos la conexion al comando
comando.Connection = sqlConnection;
//Asignamos el lector al comando
lector = comando.ExecuteReader();
//Si hay filas...
if (lector.HasRows)
{
//Mientras que el lector pueda "leer"...
while (lector.Read())
{
//Creamos un nuevo personaje con su atributo "nombre"
oPersonaje = new clsPersonaje();
oPersonaje.nombre = (string)lector["nombre"];
oPersonaje.idPersonaje = (int)lector["idPersonaje"];
//Agregamos dicho personaje a la lista de nombres
listadoNombres.Add(oPersonaje);
}
}
//Cerramos el lector y la conexion
lector.Close();
miConexion.closeConnection(ref sqlConnection);
//Retornamos la lista
return(listadoNombres);
}
public int EditarPersona_DAL(clsPersonaConNombreDeDepartamento persona)
{
clsMyConnection miconexion = new clsMyConnection();
SqlConnection sqlconnection = null;
SqlCommand sqlCommand = new SqlCommand();
int filas;
sqlconnection = miconexion.getConnection();
sqlCommand.CommandText = "UPDATE Personas SET telefono = @telefono where IDPersona = @id";
sqlCommand.Parameters.Add("@id", System.Data.SqlDbType.Int).Value = persona.idPersona;
sqlCommand.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = persona.telefono;
sqlCommand.Connection = sqlconnection;
filas = sqlCommand.ExecuteNonQuery();
miconexion.closeConnection(ref sqlconnection);
return(filas);
}
public static int ActualizarPersona_DAL(ClsPersona p1)
{
//Variables
SqlConnection conexion = null;
SqlCommand miComando = new SqlCommand();
clsMyConnection gestConexion = new clsMyConnection();
int filas = 0;
try //Try no obligatorio porque está controlado en la clase clsMyConnection
{
//Obtener conexión abierta
conexion = gestConexion.getConnection();
//Definir los parámetros del comando
miComando.CommandText = "UPDATE Personas SET nombrePersona = @nombre, apellidosPersona = @apellidos, fechaNacimiento = @fecha, telefono = @telefono, direccion = @direccion, IDDepartamento = @idDep WHERE IDPersona = @id";
//Creamos los parámetros
miComando.Parameters.Add("@id", System.Data.SqlDbType.VarChar).Value = p1.idPersona;
miComando.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = p1.nombre;
miComando.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = p1.apellidos;
miComando.Parameters.Add("@fecha", System.Data.SqlDbType.Date).Value = p1.fechaNac.DateTime;
miComando.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = p1.telefono;
miComando.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = p1.direccion;
miComando.Parameters.Add("@idDep", System.Data.SqlDbType.Int).Value = p1.idDepartamento;
//Definir la conexión del comando
miComando.Connection = conexion;
//Ejecutamos
filas = miComando.ExecuteNonQuery();
}
catch (SqlException e) { throw e; }
finally
{
gestConexion.closeConnection(ref conexion);
}
return(filas);
}
/// <summary>
/// Este metodo ofrece un listado de superheroes
/// </summary>
/// <returns>List<Superheroe> listadoSuperheroes</returns>
public List <Superheroe> listadoSuperheroesDAL()
{
clsMyConnection miConexion = new clsMyConnection();
SqlConnection connection = miConexion.getConnection();
SqlCommand miComando = new SqlCommand();
SqlDataReader miLector;
System.Type tipoDBNULL = DBNull.Value.GetType();
List <Superheroe> listadoSuperheroes = new List <Superheroe>();
Superheroe objSuperheroe;
try
{
miComando.CommandText = "SELECT * FROM superheroes";
miComando.Connection = connection;
miLector = miComando.ExecuteReader();
if (miLector.HasRows)
{
while (miLector.Read())
{
objSuperheroe = new Superheroe();
objSuperheroe.idSuperheroe = miLector["idSuperheroe"].GetType() != tipoDBNULL ? (int)miLector["idSuperheroe"] : 0;
objSuperheroe.nombreSuperheroe = miLector["nombreSuperheroe"].GetType() != tipoDBNULL ? (string)miLector["nombreSuperheroe"] : null;
objSuperheroe.asignarImagen();
listadoSuperheroes.Add(objSuperheroe);
}
}
miLector.Close();
}
catch (SqlException e)
{
throw e;
}
finally
{
miConexion.closeConnection(ref connection);
}
return(listadoSuperheroes);
}
/// <summary>
/// Metodo para borrar una persona pasandole su id
/// </summary>
/// <param name="id"></param>
/// <returns>filas</returns>
public int BorrarPersonaPorID(int id)
{
clsPersona oPersona = new clsPersona();
clsMyConnection miconexion = new clsMyConnection();
SqlConnection sqlconnection = null;
SqlCommand sqlCommand = new SqlCommand();
int filas;
try
{
//Obtener conexion abierta
sqlconnection = miconexion.getConnection();
//Definimos los parametros del comando
sqlCommand.CommandText = "DELETE FROM Personas WHERE idPersona=@id";
/*
* Definimos el parametro @id
*/
SqlParameter param;
param = new SqlParameter();
param.ParameterName = "@id";
param.SqlDbType = System.Data.SqlDbType.Int;
param.Value = id;
sqlCommand.Parameters.Add(param);
//Definir la conexion
sqlCommand.Connection = sqlconnection;
//Ejecutar la sentencia
filas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException e) { throw e; }
finally
{
miconexion.closeConnection(ref sqlconnection);
}
return(filas);
}
public List <clsDepartamento> listadoCompletoDepartamentos()
{
clsDepartamento oDepartamento;
List <clsDepartamento> lista = new List <clsDepartamento>();
clsMyConnection miConexion = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand comando = new SqlCommand();
SqlDataReader lector = null;
try
{
sqlConnection = miConexion.getConnection();
comando.CommandText = "SELECT nombreDepartamento, idDepartamento FROM Departamentos";
comando.Connection = sqlConnection;
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
oDepartamento = new clsDepartamento();
oDepartamento.nombreDepartamento = (string)lector["nombreDepartamento"];
oDepartamento.idDepartamento = (int)lector["idDepartamento"];
lista.Add(oDepartamento);
}
}
}
catch (SqlException e) { throw e; }
finally
{
miConexion.closeConnection(ref sqlConnection);
if (lector != null)
{
lector.Close();
}
}
return(lista);
}
/*TODO:
* - int insertarCombate(clsCombate nuevoCombate)
* - int checkExisteCombate(int idLuchador1, int idLuchador2, DateTime fechaCombate)
*/
/// <summary>
/// Método que inserta un nuevo combate en la BBDD
/// </summary>
/// <param name="nuevoCombate">clsCombate con los datos del nuevo combate</param>
/// <returns>int idCombate, del combate recién insertado</returns>
public int insertarCombate(clsCombate nuevoCombate)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
//int filasAfectadas;
int idCombate = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@fechaCombate", System.Data.SqlDbType.Date).Value = nuevoCombate.FechaCombate; //TODO ver si necesita castearse a DATETIME
//command.CommandText = "INSERT INTO SH_Combates VALUES (getdate()) " +
command.CommandText = "INSERT INTO SH_Combates VALUES (@fechaCombate) " +
"SELECT TOP 1 * FROM SH_Combates ORDER BY idCombate DESC"; //Pilla sólo la primera columna y de la primera fila de la última prueba insertada, en mi caso el idCombate
//Ejecuta la instrucción SQL
//filasAfectadas = command.ExecuteNonQuery();
idCombate = (int)command.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(idCombate);
}
/// <summary>
/// Metodo que devuelve un nuevo objeto persona, creado desde la vista
/// </summary>
/// <returns>clsPersona</returns>
public int InsertarPersona_DAL(clsPersona oPersona)
{
clsMyConnection miconexion = new clsMyConnection();
SqlConnection sqlconnection = null;
SqlCommand sqlCommand = new SqlCommand();
int filas;
try
{
//Obtener conexion abierta
sqlconnection = miconexion.getConnection();
//Sentencia SQL
sqlCommand.CommandText = "INSERT INTO Personas(nombrePersona, apellidosPersona, fechaNacimiento, direccion, telefono, idDepartamento) " +
"VALUES (@nombre, @apellidos, @fechaNac, @direccion, @telefono, @departamento)";
//Definicion de parametros
sqlCommand.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = oPersona.nombre;
sqlCommand.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = oPersona.apellidos;
sqlCommand.Parameters.Add("@fechaNac", System.Data.SqlDbType.Date).Value = oPersona.fechNacimiento;
sqlCommand.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = oPersona.direccion;
sqlCommand.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = oPersona.telefono;
sqlCommand.Parameters.Add("@departamento", System.Data.SqlDbType.Int).Value = oPersona.idDepartamento;
//Añadimos la conexion al comando
sqlCommand.Connection = sqlconnection;
//Ejecutamos el comando
filas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException e) { throw e; }
finally
{
//Cerramos la conexion
miconexion.closeConnection(ref sqlconnection);
}
return(filas);
}
public List <clsCategoria> listadoCompletoCategorias()
{
List <clsCategoria> listado = new List <clsCategoria>();
clsCategoria oCategoria;
clsMyConnection miConexion = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand comando = new SqlCommand();
SqlDataReader lector = null;
//Abrimos una nueva conexion
sqlConnection = miConexion.getConnection();
//Creamos una nueva sentencia a traves del CommandText
comando.CommandText = "SELECT idCategoria, nombreCategoria FROM Categorias";
//Asignamos la conexion al comando
comando.Connection = sqlConnection;
//Asignamos el lector al comando
lector = comando.ExecuteReader();
//Si hay filas...
if (lector.HasRows)
{
//Mientras que el lector pueda "leer"...
while (lector.Read())
{
oCategoria = new clsCategoria();
oCategoria.nombreCategoria = (string)lector["nombreCategoria"];
oCategoria.idCategoria = (int)lector["idCategoria"];
listado.Add(oCategoria);
}
}
//Cerramos el lector y la conexion
lector.Close();
miConexion.closeConnection(ref sqlConnection);
//Retornamos la lista
return(listado);
}
/// <summary>
/// Método que comprueba que el médico devolviendo un entero con la cantidad de filas afectadas por la sentencia
/// Que deberá ser una sola
/// </summary>
/// <param name="codigoMedico">string con el código del médico deseado</param>
/// <returns>int filasAfectadas, con los registros obtenidos</returns>
public int checkExisteMedico(string codigoMedico)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
Int32 filasAfectadas = 0;
//int filasAfectadas = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@codigoMedico", System.Data.SqlDbType.VarChar).Value = codigoMedico;
command.CommandText = "SELECT COUNT(*) FROM Medicos WHERE codigoMedico = @codigoMedico";
/*En la documentaticón de Microsoft he visto que lo hacen así, primero con tipo Int32 y luego hacen la conversión a int, no sé por qué pero lo he dejado así,
* pero lo probé con un int normal y funcionaba igualmente, así que no veo realmente el motivo de ese doble casteo*/
filasAfectadas = (Int32)command.ExecuteScalar();
//filasAfectadas = (int)command.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return((int)filasAfectadas);
//return filasAfectadas;
}
/// <summary>
/// Este método obtiene el listado completo de los departamentos de la base de datos
/// </summary>
/// <returns>El listado de los departamentos</returns>
public static List <clsDepartamento> obtenerListadoDepartamentos()
{
List <clsDepartamento> listado = new List <clsDepartamento>();
clsDepartamento departamento;
clsMyConnection conexion = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlDataReader reader;
SqlCommand command = new SqlCommand();
try
{
sqlConnection = conexion.getConnection();
command.Connection = sqlConnection;
command.CommandText = "SELECT * FROM dbo.Departamentos";
reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
departamento = new clsDepartamento();
departamento.Id = (int)reader["ID"];
departamento.Nombre = (String)reader["Nombre"];
listado.Add(departamento);
}
}
reader.Close();
}
catch (SqlException e)
{
throw e;
}
finally
{
conexion.closeConnection(ref sqlConnection);
}
return(listado);
}
/// <summary>
/// Funcion que devuelve una List de personas
/// </summary>
/// <returns>List Personas</clsPersonas></returns>
public List <clsPersona> listadoCompletoPersonas()
{
SqlConnection miConexion;
List <clsPersona> ret = new List <clsPersona>();
SqlCommand miComando = new SqlCommand();
SqlDataReader miLector;
clsPersona oPersona;
clsMyConnection connection = new clsMyConnection();
//Try no obligatorio ya que esta en clase myconnection
miConexion = connection.getConnection();
miComando.CommandText = "SELECT * FROM personas";
miComando.Connection = miConexion;
miLector = miComando.ExecuteReader();
if (miLector.HasRows)
{
while (miLector.Read())
{
oPersona = new clsPersona();
oPersona.idPersona = (int)miLector["IDPersona"];
oPersona.nombre = (String)miLector["nombrePersona"];
oPersona.Apellidos = (String)miLector["apellidosPersona"];
oPersona.fechaNacimiento = (DateTime)miLector["fechaNacimiento"];
oPersona.telefono = (String)miLector["telefono"];
oPersona.direccion = (String)miLector["direccion"];
oPersona.IdDept = (int)miLector["IDDepartamento"];
ret.Add(oPersona);
}
}
miLector.Close();
connection.closeConnection(ref miConexion);
return(ret);
}
public clsPersonaConNombreDeDepartamento PersonaConDept_DAL(int id)
{
clsPersonaConNombreDeDepartamento oPersona = new clsPersonaConNombreDeDepartamento();
SqlConnection miConexion;
SqlCommand miComando = new SqlCommand();
SqlDataReader miLector;
clsMyConnection connection = new clsMyConnection();
//Try no obligatorio ya que esta en clase myconnection
miConexion = connection.getConnection();
miComando.CommandText = "select IDPersona,nombrePersona,apellidosPersona,telefono,nombreDepartamento,Personas.IDDepartamento from Personas inner join Departamentos on Personas.IDDepartamento = Departamentos.IDDepartamento where Personas.IDPersona = @Id ";
miComando.Parameters.Add("@Id", System.Data.SqlDbType.Int).Value = id;
miComando.Connection = miConexion;
miLector = miComando.ExecuteReader();
if (miLector.HasRows)
{
while (miLector.Read())
{
oPersona.idPersona = (int)miLector["IDPersona"];
oPersona.nombre = (String)miLector["nombrePersona"];
oPersona.Apellidos = (String)miLector["apellidosPersona"];
oPersona.telefono = (String)miLector["telefono"];
oPersona.IdDept = (int)miLector["IDDepartamento"];
oPersona.nombreDepartamento = (string)miLector["nombreDepartamento"];
}
}
miLector.Close();
connection.closeConnection(ref miConexion);
return(oPersona);
}
/// <summary>
/// Método que inserta una nueva persona en la BD.
/// Devuelve un entero que representa el número de filas afectadas por la sentencia ejecutada.
/// Si ese entero es distinto de 1, no se habrá ejecutado correctamente, porque debe insertar un registro.
/// </summary>
/// <param name="nuevaPersona">Objeto clsPersona con los datos de la nueva persona a insertar</param>
/// <returns>int filasAfectadas, con el número de filas afectadas al ejecutarse</returns>
public int insertarPersona(clsPersona nuevaPersona)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@dni", System.Data.SqlDbType.VarChar).Value = nuevaPersona.DniPersona;
command.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = nuevaPersona.NombrePersona;
command.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = nuevaPersona.ApellidosPersona;
command.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = nuevaPersona.Telefono;
command.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = nuevaPersona.Direccion;
command.Parameters.Add("@diagnostico", System.Data.SqlDbType.Bit).Value = nuevaPersona.Diagnostico;
command.CommandText = "INSERT INTO Personas (dniPersona, nombrePersona, apellidosPersona, telefono, direccion, diagnostico) " +
"VALUES(@dni, @nombre, @apellidos, @telefono, @direccion, @diagnostico)";
filasAfectadas = command.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
//Método Diana
/// <summary>
/// Método que actualiza la cantidad de la línea de pedido llamando a procedimiento actualizarCantidadLineaPedido en BD
/// </summary>
/// <param name="codigoProducto">int con código del producto a cuya línea se va a modificar</param>
/// <param name="codigoPedido">int con código del pedido cuya línea se va a modificar</param>
/// <param name="nuevaCantidad">int con nueva cantidad a modificar en linea de pedido</param>
/// <returns>int filasAfectadas</returns>
public int ActualizarLineaPedidoPorIdProductoIdPedido(int codigoProducto, int codigoPedido, int nuevaCantidad)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas = 0;
try
{
connection = clsMyConnection.getConnection();
command.Connection = connection;
command.CommandText = "actualizarCantidadLineaPedido";
command.CommandType = CommandType.StoredProcedure;
//Añade los parámetros del procedimiento
command.Parameters.Add("@codigoProducto", SqlDbType.Int).Value = codigoProducto;
command.Parameters.Add("@codigoPedido", SqlDbType.Int).Value = codigoPedido;
command.Parameters.Add("@nuevaCantidad", SqlDbType.TinyInt).Value = nuevaCantidad;
filasAfectadas = command.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
clsMyConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
public int InsertarPersona_DAL(clsPersona oPersona)
{
int filas;
clsMyConnection miConexion = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand comando = new SqlCommand();
try
{
sqlConnection = miConexion.getConnection();
comando.CommandText = "INSERT INTO Personas(nombrePersona, apellidosPersona, fechaNacimiento, direccion, telefono, idDepartamento) " +
"VALUES (@nombre, @apellidos, @fechaNac, @direccion, @telefono, @departamento)";
//Definicion de parametros
comando.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = oPersona.nombre;
comando.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = oPersona.apellidos;
comando.Parameters.Add("@fechaNac", System.Data.SqlDbType.Date).Value = oPersona.fechNacimiento;
comando.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = oPersona.direccion;
comando.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = oPersona.telefono;
comando.Parameters.Add("@departamento", System.Data.SqlDbType.Int).Value = oPersona.idDepartamento;
comando.Connection = sqlConnection;
filas = comando.ExecuteNonQuery();
}
catch (SqlException e)
{
throw e;
}
finally
{
miConexion.closeConnection(ref sqlConnection);
}
return(filas);
}
/// <summary>
/// Este método devuelve un listado con las misiones no completadas
/// </summary>
/// <returns>El listado de misiones</returns>
public static List <clsMisiones> obtenerListadoMisionesNoCompletadas()
{
List <clsMisiones> listadoMisiones = new List <clsMisiones>();
SqlConnection connection = new SqlConnection();
clsMyConnection conexion = new clsMyConnection();
SqlCommand command = new SqlCommand();
SqlDataReader reader;
command.CommandText = "SELECT * FROM Misiones WHERE completada = 0";
try {
connection = conexion.getConnection();
command.Connection = connection;
reader = command.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
clsMisiones mision = new clsMisiones();
mision.Id = (int)reader["id"];
mision.Nombre = (String)reader["nombre"];
mision.Descripcion = (String)reader["descripcion"];
mision.Creditos = (int)reader["creditos"];
mision.Completada = (bool)reader["completada"];
listadoMisiones.Add(mision);
}
}
}
catch (SqlException e)
{
throw e;
}
finally {
conexion.closeConnection(ref connection);
}
return(listadoMisiones);
}
/// <summary>
/// Comentario: Este método nos permite insertar una persona en la base de datos.
/// </summary>
/// <param name="nombre">Nombre de la persona</param>
/// <param name="apellidos">Apellidos de la persona</param>
/// <param name="telefono">Telefono de la persona</param>
/// <param name="idDepartamento">Id del departamento</param>
/// <param name="fechaNacimiento">Fecha de nacimiento de la persona</param>
/// <returns>El método devuelve un valor booleano asociado al nombre, true si se ha conseguido insertar la nueva persona o false en caso contrario.</returns>
public bool insertarPersona(String nombre, String apellidos, String telefono, DateTime fechaNacimiento, int idDepartamento)
{
bool personaInsertada = true;
clsMyConnection clsMyConnection = new clsMyConnection("yeray.database.windows.net", "PersonasDB", "yeray", "Mi_tesoro");
SqlConnection connection = null;
try
{
connection = clsMyConnection.getConnection();//Es posible que no se pueda llegar a realizar la conexión y salte una excepción.
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.CommandType = CommandType.Text;
sqlCommand.CommandText = "INSERT INTO PD_Personas(NombrePersona, ApellidosPersona, IDDepartamento, FechaNacimientoPersona, TelefonoPersona) values (@NombrePersona, @ApellidosPersona, @IDDepartamento ,@FechaNacimientoPersona, @TelefonoPersona)";
sqlCommand.Parameters.Add("@NombrePersona", SqlDbType.VarChar).Value = nombre;
sqlCommand.Parameters.Add("@ApellidosPersona", SqlDbType.VarChar).Value = apellidos;
sqlCommand.Parameters.Add("@IDDepartamento", SqlDbType.Int).Value = idDepartamento;
sqlCommand.Parameters.Add("@FechaNacimientoPersona", SqlDbType.Date).Value = fechaNacimiento;
sqlCommand.Parameters.Add("@TelefonoPersona", SqlDbType.VarChar).Value = telefono;
sqlCommand.Connection = connection;
sqlCommand.ExecuteNonQuery();//Ejecutamos la inserción //De aquí también podriamos sacar el número de columnas afectadas
}
catch (Exception e)
{
personaInsertada = false;
throw e;
}
finally
{
if (connection != null)
{
clsMyConnection.closeConnection(ref connection);
}
}
return(personaInsertada);
}
public List <clsDepartamento> listadoDepartamentos()
{
List <clsDepartamento> listado = new List <clsDepartamento>();
clsDepartamento oDepartamento;
clsMyConnection miConexion = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand comando = new SqlCommand();
SqlDataReader lector = null;
try
{
sqlConnection = miConexion.getConnection();
comando.CommandText = "SELECT * FROM Departamentos";
lector = comando.ExecuteReader();
comando.Connection = sqlConnection;
if (lector.HasRows)
{
while (lector.Read())
{
oDepartamento = new clsDepartamento();
//Definir los atributos
oDepartamento.idDepartamento = (int)lector["idDepartamento"];
oDepartamento.nombreDepartamento = (string)lector["nombreDepartamento"];
//Añadir persona a la vista
listado.Add(oDepartamento);
}
}
}
catch (SqlException e) { throw e; }
finally
{
miConexion.closeConnection(ref sqlConnection);
lector.Close();
}
return(listado);
}
public int EditarPersona_DAL(clsPersona persona)
{
clsMyConnection miconexion = new clsMyConnection();
SqlConnection sqlconnection = null;
SqlCommand sqlCommand = new SqlCommand();
int filas;
try
{
sqlconnection = miconexion.getConnection();
sqlCommand.CommandText = "UPDATE Personas SET nombrePersona = @nombre, apellidosPersona = @apellidos, fechaNacimiento = @fechaNac, direccion = @direccion, telefono = @telefono, idDepartamento = @departamento WHERE idPersona = @id";
sqlCommand.Parameters.Add("@id", System.Data.SqlDbType.Int).Value = persona.idPersona;
sqlCommand.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = persona.nombre;
sqlCommand.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = persona.apellidos;
sqlCommand.Parameters.Add("@fechaNac", System.Data.SqlDbType.Date).Value = persona.fechNacimiento;
sqlCommand.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = persona.direccion;
sqlCommand.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = persona.telefono;
sqlCommand.Parameters.Add("@departamento", System.Data.SqlDbType.Int).Value = persona.idDepartamento;
sqlCommand.Connection = sqlconnection;
filas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException e)
{
throw e;
}
finally
{
miconexion.closeConnection(ref sqlconnection);
}
return(filas);
}
/// <summary>
/// Este método inserta a una persona en la base de datos
/// </summary>
/// <param name="persona">La persona a insertar</param>
/// <returns>El númeror de filas afectadas</returns>
public static int insertarPersona(clsPersona persona)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand sqlCommand = new SqlCommand();
int numeroFilasAfectadas = 0;
sqlCommand.Parameters.Add("@Nombre", System.Data.SqlDbType.NVarChar).Value = persona.Nombre;
sqlCommand.Parameters.Add("@Apellidos", System.Data.SqlDbType.NVarChar).Value = persona.Apellidos == null ? (Object)DBNull.Value : persona.Apellidos;
sqlCommand.Parameters.Add("@FechaNacimiento", System.Data.SqlDbType.Date).Value = persona.FechaNacimiento == new DateTime() ? (Object)DBNull.Value : persona.FechaNacimiento;
sqlCommand.Parameters.Add("@Foto", System.Data.SqlDbType.VarBinary).Value = persona.Imagen == null ? (Object)DBNull.Value : persona.Imagen;
sqlCommand.Parameters.Add("@Direccion", System.Data.SqlDbType.NVarChar).Value = persona.Direccion == null ? (Object)DBNull.Value : persona.Direccion;
sqlCommand.Parameters.Add("@Telefono", System.Data.SqlDbType.NVarChar).Value = persona.Telefono == null ? (Object)DBNull.Value : persona.Telefono;
sqlCommand.Parameters.Add("@IDDepartamento", System.Data.SqlDbType.Int).Value = persona.IdDepartamento == 0 ? (Object)DBNull.Value : persona.IdDepartamento;
sqlCommand.CommandText = "INSERT INTO Personas (Nombre, Apellidos, FechaNacimiento, Foto, Direccion, Telefono, IDDepartamento)" +
" Values (@Nombre, @Apellidos, @FechaNacimiento, @Foto, @Direccion, @Telefono, @IDDepartamento)";
try
{
sqlConnection = clsMyConnection.getConnection();
sqlCommand.Connection = sqlConnection;
numeroFilasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException)
{
throw;
}
finally
{
clsMyConnection.closeConnection(ref sqlConnection);
}
return(numeroFilasAfectadas);
}
/// <summary>
/// Esta función elimina de la base de datos a una persona
/// </summary>
/// <param name="persona">El id de la persona a eliminar</param>
/// <returns>El númeror de filas afectadas</returns>
public static int eliminarPersona(int id)
{
int filasAfectadas = 0;
SqlConnection sqlConnection = new SqlConnection();
clsMyConnection conexion = new clsMyConnection();
try
{
String query = "DELETE FROM dbo.Personas WHERE ID = @ID";
sqlConnection = conexion.getConnection();
SqlCommand command = new SqlCommand(query, sqlConnection);
command.Parameters.AddWithValue("@ID", id);
filasAfectadas = command.ExecuteNonQuery();
}
catch (SqlException e)
{
throw e;
}
finally
{
conexion.closeConnection(ref sqlConnection);
}
return(filasAfectadas);
}
public List <clsPersonaConNombreDeDepartamento> listadoCompletoPersonasConNombreDept()
{
clsPersonaConNombreDeDepartamento oPersona;
SqlConnection sqlConnection;
List <clsPersonaConNombreDeDepartamento> ret = new List <clsPersonaConNombreDeDepartamento>();
SqlCommand comando = new SqlCommand();
SqlDataReader lector;
clsMyConnection miConexion = new clsMyConnection();
sqlConnection = miConexion.getConnection();
comando.CommandText = "SELECT IDPersona,nombrePersona, apellidosPersona,fechaNacimiento,telefono,direccion, Departamentos.idDepartamento, nombreDepartamento FROM Personas INNER JOIN Departamentos ON Personas.IDDepartamento = Departamentos.IDDepartamento";
comando.Connection = sqlConnection;
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
oPersona = new clsPersonaConNombreDeDepartamento();
oPersona.idPersona = (int)lector["IDPersona"];
oPersona.nombre = (String)lector["nombrePersona"];
oPersona.apellidos = (string)lector["apellidosPersona"];
oPersona.fechNacimiento = (DateTime)lector["fechaNacimiento"];
oPersona.telefono = (String)lector["telefono"];
oPersona.direccion = (string)lector["direccion"];
oPersona.idDepartamento = (int)lector["idDepartamento"];
oPersona.nombreDepartamento = (string)lector["nombreDepartamento"];
ret.Add(oPersona);
}
}
lector.Close();
miConexion.closeConnection(ref sqlConnection);
return(ret);
}
/// <summary>
/// Comentario: Este método nos permite eliminar una persona de la base de datos.
/// </summary>
/// <param name="id">Id de la persona</param>
/// <returns>El método devuelve un valor booleano asociado al nombre, true si ha conseguido eliminar la persona o false en caso contrario.</returns>
public bool eliminarPersona(int id)
{
bool personaEliminada = true;
clsMyConnection clsMyConnection = new clsMyConnection("yeray.database.windows.net", "PersonasDB", "yeray", "Mi_tesoro");
SqlConnection connection = null;
try
{
connection = clsMyConnection.getConnection();
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.CommandType = CommandType.Text;
sqlCommand.CommandText = "DELETE FROM PD_Personas WHERE IdPersona = @Id";
sqlCommand.Parameters.Add("@Id", System.Data.SqlDbType.Int).Value = id;
sqlCommand.Connection = connection;
if (sqlCommand.ExecuteNonQuery() == 0)//Si no indica que se haya modificado alguna fila
{
personaEliminada = false;
}
}
catch (Exception e)
{
personaEliminada = false;
throw e;
}
finally
{
if (connection != null)
{
clsMyConnection.closeConnection(ref connection);//Cerramos la conexión con la base de datos
}
}
return(personaEliminada);
}