}//fin metodo buscarPersona
/// <summary>
/// este metodo esta guarda los cambios de la persona editada
/// </summary>
/// <param name="persona"></param>
/// <returns></returns>
public int guardarPersonaDAL(Persona persona)
{
clsMyConnection miConexion = new clsMyConnection();
SqlConnection conexion = new SqlConnection();
SqlCommand miComando = new SqlCommand();
int resultado = 0;
//
miComando.Parameters.Add("@id", System.Data.SqlDbType.Int).Value = persona.idPersona;
miComando.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = persona.nombre;
miComando.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = persona.apellidos;
miComando.Parameters.Add("@fechaNacimiento", System.Data.SqlDbType.DateTime).Value = persona.fechaNac;
miComando.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = persona.direccion;
miComando.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = persona.telefono;
try {
conexion = miConexion.getConnection();
//Actualizamos los datos de la persona en la base de datos
miComando.CommandText = "Update Personas set Nombre=@nombre,Apellidos=@apellidos," +
"FechaNacimiento=@fechaNacimiento,Direccion=@direccion,Telefono=@telefono " +
"where ID=@id";
//
miComando.Connection = conexion;
//ejecutamos el comando de actualizar
resultado = miComando.ExecuteNonQuery();
}
catch (SqlException sql) { throw sql; }
return(resultado);
}//fin guardarPersonaDAL
public List <clsDepartamento> listadoCompletoPersonasConNombreDept()
{
SqlConnection miConexion;
List <clsDepartamento> ret = new List <clsDepartamento>();
SqlCommand miComando = new SqlCommand();
SqlDataReader miLector;
clsDepartamento oDept;
clsMyConnection connection = new clsMyConnection();
//Try no obligatorio ya que esta en clase myconnection
miConexion = connection.getConnection();
miComando.CommandText = "SELECT * FROM Departamentos";
miComando.Connection = miConexion;
miLector = miComando.ExecuteReader();
if (miLector.HasRows)
{
while (miLector.Read())
{
oDept = new clsDepartamento();
oDept.Id = (int)miLector["IDDepartamento"];
oDept.Nombre = (String)miLector["nombreDepartamento"];
ret.Add(oDept);
}
}
miLector.Close();
connection.closeConnection(ref miConexion);
return(ret);
}
/// <summary>
/// Método que crea un nuevo pedido llamando a procedimiento en BBDD y devuelve el código del pedido insertado
/// </summary>
/// <returns>int codigoNuevoPedido</returns>
public int InsertarNuevoPedidoDevolviendoSuCodigo() //No recibe parámetros, porque en BBDD crea uno con los mismos datos de base
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int codigoNuevoPedido = 0;
try
{
connection = clsMyConnection.getConnection();
command.Connection = connection;
//Se le pasa el nombre del procedimiento a ejecutar
command.CommandText = "crearPedido";
//Para que llame al procedimiento almacenado
command.CommandType = CommandType.StoredProcedure;
//Devuelve la primera columna de la primera fila insertada, en nuestro caso el código del pedido
codigoNuevoPedido = Convert.ToInt32(command.ExecuteScalar());
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
clsMyConnection.closeConnection(ref connection);
}
}
return(codigoNuevoPedido);
}
/// <summary>
/// Método que inserta un nuevo jugador en la BD
/// </summary>
/// <param name="nuevoJugador">objeto clsJugador nuevoJugador</param>
/// <returns>int filasAfectadas</returns>
public int InsertNuevoJugador(clsJugador nuevoJugador)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@nombreJugador", System.Data.SqlDbType.VarChar).Value = nuevoJugador.NombreJugador;
command.Parameters.Add("@puntuacionJugador", System.Data.SqlDbType.Int).Value = nuevoJugador.Aciertos;
command.CommandText = "INSERT INTO TopScoresSimon (nombreJugador, aciertos) VALUES (@nombreJugador, @puntuacionJugador)";
filasAfectadas = command.ExecuteNonQuery();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
/// <summary>
/// Este método inserta en la base de datos un nuevo artista en un evento
/// </summary>
/// <param name="artista">El nick del artista</param>
/// <param name="idEvento">El id del evento</param>
/// <returns>El número de filas afectadas</returns>
public static int insertarArtistaAEvento(string artista, int idEvento)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand sqlCommand = new SqlCommand();
int numeroFilasAfectadas = 0;
sqlCommand.Parameters.AddWithValue("@NickArtista", artista);
sqlCommand.Parameters.AddWithValue("@IDEvento", idEvento);
sqlCommand.CommandText = "INSERT INTO ArtistaEvento (NickArtista, IDEvento) Values (@NickArtista, @IDEvento)";
try
{
sqlConnection = clsMyConnection.getConnection();
sqlCommand.Connection = sqlConnection;
numeroFilasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException)
{
throw;
}
finally
{
clsMyConnection.closeConnection(ref sqlConnection);
}
return(numeroFilasAfectadas);
}
/// <summary>
/// Funcion la cual borra una persona, y nos devolvera si numero de filas
/// </summary>
/// <param name="id"></param>
/// <returns>int</returns>
public int BorrarPersonaPorId_DAL(int id)
{
SqlConnection miConexion;
SqlCommand miComando = new SqlCommand();
int filas;
clsMyConnection connection = new clsMyConnection();
miConexion = connection.getConnection();
miComando.CommandText = "DELETE FROM personas where IDPersona = @id";
miComando.Connection = miConexion;
SqlParameter param;
param = new SqlParameter();
param.ParameterName = "@id";
param.SqlDbType = System.Data.SqlDbType.Int;
param.Value = id;
miComando.Parameters.Add(param);
//Tener en cuenta ExecuteNonQuery porque devuelve filas
filas = miComando.ExecuteNonQuery();
return(filas);
}
/// <summary>
/// Metodo el cual nos creara una persona
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public int CrearPersona_DAL(clsPersona nPersona)
{
SqlConnection miConexion;
SqlCommand miComando = new SqlCommand();
int filas;
clsMyConnection connection = new clsMyConnection();
miConexion = connection.getConnection();
miComando.CommandText = "INSERT INTO Personas(nombrePersona,apellidosPersona,fechaNacimiento,telefono,direccion,IDDepartamento)values(@nombre,@apellidos,@fechaNac,@telefono,@direccion,@Iddept)";
miComando.Connection = miConexion;
SqlParameter param;
param = new SqlParameter();
miComando.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = nPersona.nombre;
miComando.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = nPersona.Apellidos;
miComando.Parameters.Add("@fechaNac", System.Data.SqlDbType.DateTime).Value = nPersona.fechaNacimiento;
miComando.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = nPersona.telefono;
miComando.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = nPersona.direccion;
miComando.Parameters.Add("@Iddept", System.Data.SqlDbType.Int).Value = nPersona.IdDept;
//Tener en cuenta ExecuteNonQuery porque devuelve filas
filas = miComando.ExecuteNonQuery();
return(filas);
}
/// <summary>
/// Este método actualiza la contraseña de un usuario
/// </summary>
/// <param name="email">El email</param>
/// <param name="password">La nueva contraseña</param>
/// <returns>El número de filas afectadas</returns>
public static int actualizarPassword(String email, String password)
{
SqlConnection sqlConnection = new SqlConnection();
clsMyConnection conexion = new clsMyConnection();
SqlCommand sqlCommand = new SqlCommand();
int filasAfectadas = 0;
sqlCommand.Parameters.AddWithValue("@Password", password);
sqlCommand.Parameters.AddWithValue("@Email", email);
sqlCommand.CommandText = "UPDATE Usuario SET Password = @Password WHERE Email = @Email";
try
{
sqlConnection = conexion.getConnection();
sqlCommand.Connection = sqlConnection;
filasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException e)
{
throw e;
}
finally
{
conexion.closeConnection(ref sqlConnection);
}
return(filasAfectadas);
}
public static ClsPersona PersonaPorID_DAL(int id)
{
//Variables
SqlConnection conexion = null;
SqlDataReader miLector = null;
SqlCommand miComando = new SqlCommand();
SqlParameter param;
clsMyConnection gestConexion = new clsMyConnection();
ClsPersona p1 = null;
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 = "SELECT * FROM Personas WHERE IDPersona = @id";
//Creamos los parámetros
param = new SqlParameter();
param.ParameterName = "@id";
param.SqlDbType = System.Data.SqlDbType.Int;
param.Value = id;
miComando.Parameters.Add(param);
//Otra forma:
//miComando.Parameters.Add("@nombre", System.Data.SqlDbType.Int).Value = id;
//Definir la conexión del comando
miComando.Connection = conexion;
//Ejecutamos
miLector = miComando.ExecuteReader();
//Comprobar si el lector tiene la fila, si afirmativo, se lee y se obtiene la clase persona
if (miLector.HasRows)
{
//Leemos la fila
miLector.Read();
p1 = new ClsPersona();
//Definir los atributos del objeto
p1.idPersona = (int)miLector["IDPersona"];
p1.nombre = (string)miLector["nombrePersona"];
p1.apellidos = (string)miLector["apellidosPersona"];
p1.fechaNac = new DateTimeOffset((DateTime)miLector["fechaNacimiento"]);
p1.telefono = (string)miLector["telefono"];
p1.direccion = (string)miLector["direccion"];
p1.idDepartamento = (int)miLector["IDDepartamento"];
}
}
catch (SqlException e) { throw e; }
finally
{
gestConexion.closeConnection(ref conexion);
miLector.Close();
}
return(p1);
}
/// <summary>
/// Este método comprueba en la base de datos si ya existe un usuario con un email determinado
/// </summary>
/// <param name="email">El email</param>
/// <returns>Se devuelve 1 en caso de existir ya un usuario con tal email y 0 en caso contrario</returns>
public static int comprobarExistenciaUsuarioPorEmail(String email)
{
clsMyConnection conexion = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand command = new SqlCommand();
SqlDataReader reader;
int usuarioEncontrado = 0;
command.Parameters.AddWithValue("@Email", email);
try
{
sqlConnection = conexion.getConnection();
command.CommandText = "SELECT * FROM dbo.Usuario WHERE Email = @Email";
command.Connection = sqlConnection;
reader = command.ExecuteReader();
if (reader.HasRows)
{
usuarioEncontrado = 1;
}
reader.Close();
}
catch (SqlException e)
{
throw e;
}
finally
{
conexion.closeConnection(ref sqlConnection);
}
return(usuarioEncontrado);
}
/// <summary>
/// Este método actualiza los datos de un usuario
/// </summary>
/// <param name="id">El nick del usuario</param>
/// <param name="usuario">El usuario con los datos cambiados</param>
/// <returns>El número de filas afectadas</returns>
public static int actualizarUsuario(string id, clsUsuario usuario)
{
SqlConnection sqlConnection = new SqlConnection();
clsMyConnection conexion = new clsMyConnection();
SqlCommand sqlCommand = new SqlCommand();
int filasAfectadas = 0;
sqlCommand.Parameters.AddWithValue("@Nick", usuario.Nick);
sqlCommand.Parameters.AddWithValue("@Nombre", usuario.Nombre);
sqlCommand.Parameters.AddWithValue("@Password", usuario.Password);
sqlCommand.Parameters.AddWithValue("@Imagen", usuario.Imagen);
sqlCommand.Parameters.AddWithValue("@Tipo", usuario.Tipo);
sqlCommand.Parameters.AddWithValue("@Email", usuario.Email);
sqlCommand.Parameters.AddWithValue("@ID", id);
sqlCommand.CommandText = "UPDATE Usuario SET Nick = @Nick, Email = @Email, Nombre = @Nombre, Password = @Password, Imagen = @Imagen, Tipo = @Tipo WHERE Nick = @ID";
try
{
sqlConnection = conexion.getConnection();
sqlCommand.Connection = sqlConnection;
filasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException e)
{
throw e;
}
finally
{
conexion.closeConnection(ref sqlConnection);
}
return(filasAfectadas);
}
/// <summary>
/// Este método inserta a un nuevo usuario en la base de datos
/// </summary>
/// <param name="usuario">El usuario a insertar</param>
/// <returns>El númeror de filas afectadas</returns>
public static int insertarUsuario(clsUsuario usuario)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand sqlCommand = new SqlCommand();
int numeroFilasAfectadas = 0;
sqlCommand.Parameters.AddWithValue("@Nick", usuario.Nick);
sqlCommand.Parameters.AddWithValue("@Email", usuario.Email);
sqlCommand.Parameters.AddWithValue("@Nombre", usuario.Nombre);
sqlCommand.Parameters.AddWithValue("@Password", usuario.Password);
sqlCommand.Parameters.AddWithValue("@Imagen", usuario.Imagen);
sqlCommand.Parameters.AddWithValue("@Tipo", usuario.Tipo);
sqlCommand.CommandText = "INSERT INTO Usuario (Nick, Email, Nombre, Password, Imagen, Tipo) Values (@Nick, @Email, @Nombre, @Password, @Imagen, @Tipo)";
try
{
sqlConnection = clsMyConnection.getConnection();
sqlCommand.Connection = sqlConnection;
numeroFilasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException)
{
throw;
}
finally
{
clsMyConnection.closeConnection(ref sqlConnection);
}
return(numeroFilasAfectadas);
}
/// <summary>
/// Este método actualiza las misiones completadas
/// </summary>
/// <param name="listadoMisiones">El listado de misiones a actualizar</param>
/// <returns>El número de misiones actualizadas</returns>
public static int actualizarListadoMisiones(List <clsMisiones> listadoMisiones)
{
int filasAfectadas = 0;
SqlConnection connection = new SqlConnection();
clsMyConnection conexion = new clsMyConnection();
SqlCommand command = new SqlCommand();
command.CommandText = "UPDATE Misiones SET completada = @completa WHERE ID = @ID";
command.Parameters.AddWithValue("@completa", 1);
try {
connection = conexion.getConnection();
command.Connection = connection;
foreach (clsMisiones mision in listadoMisiones)
{
command.Parameters.AddWithValue("@ID", mision.Id);
command.ExecuteNonQuery();
}
}
catch (SqlException e)
{
throw e;
}
finally {
conexion.closeConnection(ref connection);
}
return(filasAfectadas);
}
public static int insertarPost(int id, clsPost post)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand sqlCommand = new SqlCommand();
DateTime localDate = DateTime.Now;
sqlCommand.Parameters.AddWithValue("@IDEvento", id);
sqlCommand.Parameters.AddWithValue("@NickUsuario", post.NickUsuario);
sqlCommand.Parameters.AddWithValue("@Contenido", post.Contenido);
sqlCommand.Parameters.AddWithValue("@FechaPost", localDate); //REALMENTE OBTENGO EL VALOR DE LA FECHA CUANDO LLEGA A ESTE PUNTO DEL CÓDIGO, PORQUE SI LO COJO DESDE LA APP HAY MUCHOS
//PROBLEMAS DEBIDO AL CAMBIO DE REGIONES ENTRE DISTINTOS DISPOSITIVOS, EL PARSEO Y DEMÁS
sqlCommand.CommandText = "INSERT INTO Post (IDEvento, NickUsuario, Contenido, FechaPost) Values (@IDEvento, @NickUsuario, @Contenido, @FechaPost)";
try
{
sqlConnection = clsMyConnection.getConnection();
sqlCommand.Connection = sqlConnection;
int filasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException)
{
throw;
}
finally
{
clsMyConnection.closeConnection(ref sqlConnection);
}
return(id);
}
/// <summary>
/// Este método inserta una nueva sala en la base de datos
/// </summary>
/// <param name="sala">La sala a insertar</param>
/// <returns>El númeror de filas afectadas</returns>
public static int insertarSala(clsSala sala)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand sqlCommand = new SqlCommand();
int numeroFilasAfectadas = 0;
sqlCommand.Parameters.AddWithValue("@Nick", sala.Nick);
sqlCommand.Parameters.AddWithValue("@Localidad", sala.Localidad);
sqlCommand.Parameters.AddWithValue("@Direccion", sala.Direccion);
sqlCommand.Parameters.AddWithValue("@Provincia", sala.Provincia);
sqlCommand.CommandText = "INSERT INTO Sala (Nick, Localidad, Direccion, Provincia) Values (@Nick, @Localidad, @Direccion, @Provincia)";
try
{
sqlConnection = clsMyConnection.getConnection();
sqlCommand.Connection = sqlConnection;
numeroFilasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException)
{
throw;
}
finally
{
clsMyConnection.closeConnection(ref sqlConnection);
}
return(numeroFilasAfectadas);
}
public async Task <ObservableCollection <clsPersona> > ListadoPersonas()
{
ObservableCollection <clsPersona> listadoPersonas = new ObservableCollection <clsPersona>();
HttpClient cliente = new HttpClient();
String uriBase = new clsMyConnection().getUriBase();
Uri requestUri = new Uri(uriBase + "PersonasAPI");
//Send the GET request asynchronously and retrieve the response as a string.
HttpResponseMessage httpResponse = new HttpResponseMessage();
string httpResponseBody = "";
try
{
//Send the GET request
httpResponse = await cliente.GetAsync(requestUri);
httpResponse.EnsureSuccessStatusCode();
httpResponseBody = await httpResponse.Content.ReadAsStringAsync();
listadoPersonas = JsonConvert.DeserializeObject <ObservableCollection <clsPersona> >(httpResponseBody);
}
catch (Exception e)
{
httpResponseBody = "Error: " + e.HResult.ToString("X") + " Message: " + e.Message;
}
return(listadoPersonas);
}
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";
comando.Connection = sqlConnection;
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
oDepartamento = new clsDepartamento();
oDepartamento.idDepartamento = (int)lector["idDepartamento"];
oDepartamento.nombreDepartamento = (string)lector["nombreDepartamento"];
listado.Add(oDepartamento);
}
}
}
catch (SqlException e) { throw e; }
finally
{
miConexion.closeConnection(ref sqlConnection);
lector.Close();
}
return(listado);
}
/// <summary>
/// elimina la persona cuyo id corresponda al recibido
/// conectandose a la bbdd. Si no borra nada devuelve -1
/// </summary>
/// <param name="id"></param>
/// <returns>numero de filas borradas</returns>
public int dropPersonaID_DAL(int id)
{
SqlConnection miConexion;
SqlCommand miComando = new SqlCommand();
clsMyConnection gestoraConexion = new clsMyConnection();
clsPersona persona = null;
int numberOfDeletes = -1;
//Algoritmo
miConexion = gestoraConexion.getConnection(); //No es necesario poner try/catch porque myConnection ya lo gestiona
SqlParameter idpersonaSQL = new SqlParameter();
idpersonaSQL.SqlDbType = System.Data.SqlDbType.Int;
idpersonaSQL.ParameterName = "@id";
idpersonaSQL.Value = id;
miComando.Parameters.Add(idpersonaSQL);
//Otra manera de declarar un parametro SQL, para intentar evitar SQL injection
//miComando.Parameters.Add("@id", System.Data.SqlDbType.Int).Value = id;
miComando.CommandText = "DELETE FROM Personas WHERE IDPersona = @id";
miComando.Connection = miConexion;
numberOfDeletes = miComando.ExecuteNonQuery();
//Cerrar conexion
gestoraConexion.closeConnection(ref miConexion);
return(numberOfDeletes);
}
/// <summary>
///
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
public int ActualizarPersona_DAL(clsPersona p)
{
int filas;
SqlConnection miConexion;
SqlCommand miComando = new SqlCommand();
clsMyConnection connection = new clsMyConnection();
miConexion = connection.getConnection();
miComando.CommandText = "update Personas set nombrePersona = @nombre,apellidosPersona = @apellidos,fechaNacimiento = @fechaNac,telefono = @telefono,direccion = @direccion,IDDepartamento = @Iddept where IDPersona = @id";
miComando.Connection = miConexion;
SqlParameter param;
param = new SqlParameter();
miComando.Parameters.Add("@id", System.Data.SqlDbType.Int).Value = p.idPersona;
miComando.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = p.nombre;
miComando.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = p.Apellidos;
miComando.Parameters.Add("@fechaNac", System.Data.SqlDbType.DateTime).Value = p.fechaNacimiento;
miComando.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = p.telefono;
miComando.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = p.direccion;
miComando.Parameters.Add("@Iddept", System.Data.SqlDbType.Int).Value = p.IdDept;
//Tener en cuenta ExecuteNonQuery porque devuelve filas
filas = miComando.ExecuteNonQuery();
return(filas);
}
public int insertPersona_DAL(clsPersona personaAInsertar)
{
int numberOfRows = -1;
SqlConnection miConexion;
SqlCommand miComando = new SqlCommand();
clsMyConnection gestoraConexion = new clsMyConnection();
//Algoritmo
miConexion = gestoraConexion.getConnection(); //No es necesario poner try/catch porque myConnection ya lo gestiona
//Otra manera de declarar un parametro SQL, para intentar evitar SQL injection
miComando.Parameters.Add("@nombre", System.Data.SqlDbType.VarChar).Value = personaAInsertar.nombre;
miComando.Parameters.Add("@apellidos", System.Data.SqlDbType.VarChar).Value = personaAInsertar.apellidos;
miComando.Parameters.Add("@fechaNacimiento", System.Data.SqlDbType.Date).Value = personaAInsertar.fechaNacimiento;
miComando.Parameters.Add("@telefono", System.Data.SqlDbType.VarChar).Value = personaAInsertar.telefono;
miComando.Parameters.Add("@direccion", System.Data.SqlDbType.VarChar).Value = personaAInsertar.direccion;
miComando.Parameters.Add("@idDepartamento", System.Data.SqlDbType.Int).Value = personaAInsertar.idDepartamento;
miComando.CommandText = "INSERT INTO [Personas] VALUES (@nombre, @apellidos, @fechaNacimiento, @telefono, @direccion, @idDepartamento)";
miComando.Connection = miConexion;
numberOfRows = miComando.ExecuteNonQuery();
//Cerrar conexion
gestoraConexion.closeConnection(ref miConexion);
return(numberOfRows);
}
/// <summary>
/// Método que comprueba que el jugador existe devolviendo un entero con la cantidad de filas afectadas por la sentencia
/// que deberá ser una sola
/// </summary>
/// <param name="nick">string con el nick del jugador a buscar</param>
/// <param name="password">string con la contraseña del jugador a buscar</param>
/// <returns>int filasAfectadas, con los registros obtenidos</returns>
public int checkExisteJugador(string nick, string password)
{
clsMyConnection objConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
Int32 filasAfectadas = 0;
try
{
connection = objConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@nick", System.Data.SqlDbType.VarChar).Value = nick;
command.Parameters.Add("@password", System.Data.SqlDbType.VarChar).Value = password;
command.CommandText = "SELECT COUNT(*) FROM CJ_Jugadores WHERE nick = @nick AND contraseña = @password";
filasAfectadas = (Int32)command.ExecuteScalar();
}
catch (Exception e)
{
throw e;
}
finally
{
if (connection != null)
{
objConnection.closeConnection(ref connection);
}
}
//Este doble casteo lo hago porque en la documentación lo he visto así, pero no lo entiendo, hasta el VS te dice que la conversión es redundante
return((int)filasAfectadas);
}
/// <summary>
/// Intetara borrar a una persona de la bbdd segun la id que nos envien, devolverá un entero con el num. de filas
/// afectadas (1 o 0), si algo falla en la conexion Saltará una excepcion sql.
/// </summary>
/// <param name="id">entero id que hace referencia a la id de la persona a borrar</param>
/// <returns>retorna un entero con el numero de filas afectadas en la bbdd,
/// si todo va bien retornará 1 (que ha borrado a una persona),
/// si no ha encontrado a la persona retornara 0,
///</returns>
public int deleteClient(int id)
{
int resultado = 0;
clsMyConnection myconexion = new clsMyConnection();
SqlConnection conexion = new SqlConnection();
SqlCommand comando = new SqlCommand();
comando.Parameters.Add("@id", System.Data.SqlDbType.Int).Value = id;
try
{
conexion = miConexion.getConnection();
comando = new SqlCommand();
//Comando Sql
comando.CommandText = "Delete from personas Where IDPersona = " + id;
comando.Connection = conexion;
resultado = comando.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
conexion.Close();
}
return(resultado);
}
/// <summary>
/// Inserta una linea de pedido en un pedido concreto.
/// </summary>
/// <param name="lineaPedido">Linea de pedido a insertar</param>
/// <returns>Numero de filas afectadas</returns>
public int insertarLineaPedidoEnPedido(clsLineaPedido lineaPedido)
{
int filas = 0;
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection connection = null;
try {
connection = clsMyConnection.getConnection();
SqlCommand cmd = new SqlCommand(
"crearLineaPedido", connection);
// Decimos que se trata de un procedure
cmd.CommandType = CommandType.StoredProcedure;
// Añadimos los parametros al procedure
cmd.Parameters.Add(new SqlParameter("@codigoProducto", lineaPedido.CodigoProducto));
cmd.Parameters.Add(new SqlParameter("@codigoPedido", lineaPedido.CodigoPedido));
cmd.Parameters.Add(new SqlParameter("@cantidad", lineaPedido.Cantidad));
cmd.Parameters.Add(new SqlParameter("@precioUnitario", lineaPedido.PrecioUnitario));
cmd.Parameters.Add(new SqlParameter("@Divisa", lineaPedido.Divisa));
//Ejecutamos el procedimiento.
filas = cmd.ExecuteNonQuery();
} catch (Exception e) {
throw e;
}
return(filas);
}
/// <summary>
/// Método que devuelve el listado de departamentos de la base de datos
/// </summary>
/// <returns>ObservableCollection<clsDepartamento> listadoDepartamentos</returns>
public ObservableCollection <clsDepartamento> ListadoCompletoDepartamentos() //Consulta para obtener el listado de departamentos
{
//Abro conexión
objConexion = new clsMyConnection();
conexion = objConexion.getConnection();
//Guardo sentencia en comando
comando.CommandText = "SELECT * FROM PD_Departamentos";
//Paso conexión al comando
comando.Connection = conexion;
//Ejecuta el comando
lector = comando.ExecuteReader();
ObservableCollection <clsDepartamento> listadoDepartamentos = new ObservableCollection <clsDepartamento>();
if (lector.HasRows) //si hay lineas por leer
{
while (lector.Read())
{
objDepartamento = new clsDepartamento(); //Creo un departamento para cada registro
objDepartamento.IdDepartamento = (int)lector["IdDepartamento"];
objDepartamento.NombreDepartamento = (string)lector["NombreDepartamento"];
listadoDepartamentos.Add(objDepartamento); //Añade el objeto persona del registro al listado Personas
}
}
return(listadoDepartamentos); //Devuelve la lista de personas creada para la consulta
}
public clsPersonaConNombreDeDepartamento personaConNombreDeDepartamento(int id)
{
clsPersonaConNombreDeDepartamento oPersona = new clsPersonaConNombreDeDepartamento();;
SqlConnection sqlConnection;
SqlCommand comando = new SqlCommand();
SqlDataReader lector;
clsMyConnection miConexion = new clsMyConnection();
sqlConnection = miConexion.getConnection();
comando.CommandText = "SELECT IDPersona, apellidosPersona, nombrePersona,fechaNacimiento,telefono,direccion, Personas.idDepartamento, nombreDepartamento FROM Personas INNER JOIN Departamentos ON Personas.IDDepartamento = Departamentos.IDDepartamento WHERE idPersona = @id";
comando.Parameters.Add("@id", System.Data.SqlDbType.Int).Value = id;
comando.Connection = sqlConnection;
lector = comando.ExecuteReader();
if (lector.HasRows)
{
while (lector.Read())
{
oPersona.idPersona = (int)lector["IDPersona"];
oPersona.apellidos = (string)lector["apellidosPersona"];
oPersona.nombre = (String)lector["nombrePersona"];
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"];
}
}
miConexion.closeConnection(ref sqlConnection);
lector.Close();
return(oPersona);
}
/// <summary>
/// Este metodo devuelve un listado de ciudades
/// </summary>
/// <returns>listado de ciudades</returns>
public async Task <List <clsCiudad> > listadoCiudades()
{
List <clsCiudad> listadoCiudades = new List <clsCiudad>();
HttpClient miCliente = new HttpClient();
clsMyConnection miConexion = new clsMyConnection();
String uriBase = miConexion.getUriBase();
Uri requestUri = new Uri(uriBase + "ciudades");
//Send the GET request asynchronously and retrieve the response as a string.
HttpResponseMessage httpResponse = new HttpResponseMessage();
string httpResponseBody = "";
try
{
//Send the GET request
httpResponse = await miCliente.GetAsync(requestUri);
httpResponse.EnsureSuccessStatusCode();
httpResponseBody = await httpResponse.Content.ReadAsStringAsync();
listadoCiudades = JsonConvert.DeserializeObject <List <clsCiudad> >(httpResponseBody);
}
catch (Exception ex)
{
httpResponseBody = "Error: " + ex.HResult.ToString("X") + " Message: " + ex.Message;
}
return(listadoCiudades);
}
/// <summary>
/// Este método inserta en la base de datos un nuevo artista
/// </summary>
/// <param name="artista">El artista</param>
/// <returns>El número de filas afectadas</returns>
public static int insertarArtista(clsArtista artista)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection sqlConnection = new SqlConnection();
SqlCommand sqlCommand = new SqlCommand();
int numeroFilasAfectadas = 0;
sqlCommand.Parameters.AddWithValue("@Nick", artista.Nick);
sqlCommand.Parameters.AddWithValue("@Biografia", artista.Biografia);
sqlCommand.Parameters.AddWithValue("@Link", artista.Link);
sqlCommand.Parameters.AddWithValue("@Genero", artista.Genero);
sqlCommand.CommandText = "INSERT INTO Artista (Nick, Biografia, Link, Genero) Values (@Nick, @Biografia, @Link, @Genero)";
try
{
sqlConnection = clsMyConnection.getConnection();
sqlCommand.Connection = sqlConnection;
numeroFilasAfectadas = sqlCommand.ExecuteNonQuery();
}
catch (SqlException)
{
throw;
}
finally
{
clsMyConnection.closeConnection(ref sqlConnection);
}
return(numeroFilasAfectadas);
}
/// <summary>
/// Este método actualiza a una persona de la base de datos
/// </summary>
/// <param name="persona">La persona a actualizar</param>
/// <returns>El númeror de filas afectadas</returns>
public static int actualizarPersona(clsPersona persona)
{
SqlConnection sqlConnection = new SqlConnection();
clsMyConnection conexion = new clsMyConnection();
SqlCommand command = new SqlCommand();
int filasAfectadas = 0;
try {
sqlConnection = conexion.getConnection();
command.Connection = sqlConnection;
command.CommandText = "set dateformat dmy";
command.ExecuteNonQuery();
command.CommandText = $"UPDATE Personas " +
$"SET Nombre = '{persona.Nombre}' ,Apellidos = '{persona.Apellidos}' ," +
$"FechaNacimiento = '{persona.FechaNacimiento}'," + //,Foto = {persona.Imagen} //LA MALDITA FOTO FALLA
$"Direccion = '{persona.Direccion}' ,Telefono = '{persona.Telefono}' ," +
$"IDDepartamento = {persona.IdDepartamento} " +
$"WHERE ID = {persona.Id}";
filasAfectadas = command.ExecuteNonQuery();
}
catch (SqlException e)
{
throw e;
}
finally {
conexion.closeConnection(ref sqlConnection);
}
return(filasAfectadas);
}
/// <summary>
/// Método que actualiza un pedido determinado según su Id
/// </summary>
/// <param name="pedidoParaModificar">Objeto clsPedido que se va a modificar</param>
/// <returns>int filasAfectadas</returns>
public int ActualizarPedidoPorId(clsPedido pedidoParaModificar)
{
clsMyConnection clsMyConnection = new clsMyConnection();
SqlConnection connection = null;
SqlCommand command = new SqlCommand();
int filasAfectadas = 0;
try
{
connection = clsMyConnection.getConnection();
command.Connection = connection;
command.Parameters.Add("@codigo", System.Data.SqlDbType.Int).Value = pedidoParaModificar.Codigo;
command.Parameters.Add("@estado", System.Data.SqlDbType.VarChar).Value = pedidoParaModificar.Estado;
command.Parameters.Add("@fechaPedido", System.Data.SqlDbType.DateTime).Value = pedidoParaModificar.FechaPedido;
command.Parameters.Add("@fechaRecepcion", System.Data.SqlDbType.DateTime).Value = pedidoParaModificar.FechaRecepcion;
command.CommandText = "UPDATE ERP_Pedidos SET Estado = @estado, FechaPedido = @fechaPedido, FechaRecepcion= @fechaRecepcion WHERE Codigo = @codigo";
filasAfectadas = command.ExecuteNonQuery();
}catch (Exception e)
{
throw e;
}
finally
{
if (clsMyConnection != null)
{
clsMyConnection.closeConnection(ref connection);
}
}
return(filasAfectadas);
}
}//fin guardarPersonaDAL
public int eliminarPersonaDAL(int id)
{
clsMyConnection miConexion = new clsMyConnection();
SqlConnection conexion = new SqlConnection();
SqlCommand miComando = new SqlCommand();
int filasAfectadas = 0;
SqlParameter param;
param = new SqlParameter();
param.ParameterName = "@id";
param.SqlDbType = System.Data.SqlDbType.Int;
param.Value = id;
//Le damos al comando el paramentro
miComando.Parameters.Add(param);
try {
conexion = miConexion.getConnection();
miComando.CommandText = "Delete From Personas where ID=@id";
miComando.Connection = conexion; //no olvides esto
filasAfectadas = miComando.ExecuteNonQuery();
}catch (Exception e) { throw e; }
return(filasAfectadas);
}
