//-> metodo para buscar solo el nombre de las familias, lo mismo en vez de recibir el campo en cuestion indicamos toda la clase
//public DataTable BuscarNombre (DCategoria Categoria)
public DataTable BuscarNombreTrabajador(DTrabajadores Trabajadores)
{
DataTable DtResultado = new DataTable("Trabajadores");
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spbuscar_trabajador_nombre";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParTextoBuscar = new SqlParameter();
ParTextoBuscar.ParameterName = "@textobuscar";
ParTextoBuscar.SqlDbType = SqlDbType.VarChar;
ParTextoBuscar.Size = 50;
ParTextoBuscar.Value = Trabajadores.CTextoBuscar;
SqlCmd.Parameters.Add(ParTextoBuscar);
SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
SqlDat.Fill(DtResultado);
}
catch (Exception ex)
{
DtResultado = null;
}
return(DtResultado);
}
//------------------- METODO BAJAS/ELIMINAR -----------------------------------------------------------------
public string Eliminar(DTrabajadores Trabajadores)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
//Código
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Establecer el Comando
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spEliminar_trabajador";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdTrabajador = new SqlParameter(); //-> Esto es para "parametrizar", poder enviar parametros en consultas
ParIdTrabajador.ParameterName = "@idTrabajador"; //-> Nombre del parametro, este es el mismo que tengo puesto en el PRC
ParIdTrabajador.SqlDbType = SqlDbType.Int; //-> Tipo del campo
ParIdTrabajador.Value = Trabajadores.IdTrabajador; //Toma el valor de la propiedad
SqlCmd.Parameters.Add(ParIdTrabajador); //-> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//Ejecutamos nuestro comando, es decir estamos llamando al procedimiento almacenado para que se ejecute
rpta = SqlCmd.ExecuteNonQuery() == 1 ? "OK" : "NO se Elimino el Registro";
}
catch (Exception ex)
{
rpta = ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(rpta);
}
//------------------- METODO ACCESO Y CONTROL PERFILES -------------------------------------------------------
public DataTable Login(DTrabajadores Trabajadores)
{
DataTable DtResultado = new DataTable("Trabajadores");
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "splogin";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParUsuario = new SqlParameter();
ParUsuario.ParameterName = "@usuario";
ParUsuario.SqlDbType = SqlDbType.VarChar;
ParUsuario.Size = 20;
ParUsuario.Value = Trabajadores.CUsuario;
SqlCmd.Parameters.Add(ParUsuario);
SqlParameter ParPassword = new SqlParameter();
ParPassword.ParameterName = "@password";
ParPassword.SqlDbType = SqlDbType.VarChar;
ParPassword.Size = 20;
ParPassword.Value = Trabajadores.Password;
SqlCmd.Parameters.Add(ParPassword);
SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
SqlDat.Fill(DtResultado);
}
catch (Exception ex)
{
DtResultado = null;
}
return(DtResultado);
}
//------------------- METODO MODIFICAR/EDITAR -----------------------------------------------------------------
public string Editar(DTrabajadores Trabajadores)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Establecer el Comando
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spEditar_trabajador";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdTrabajador = new SqlParameter(); //-> Esto es para "parametrizar", poder enviar parametros en consultas
ParIdTrabajador.ParameterName = "@idTrabajador"; //-> Nombre del parametro, este es el mismo que tengo puesto en el PRC
ParIdTrabajador.SqlDbType = SqlDbType.Int; //-> Tipo del campo
ParIdTrabajador.Value = Trabajadores.IdTrabajador; //Toma el valor de la propiedad
SqlCmd.Parameters.Add(ParIdTrabajador); //-> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//---//
SqlParameter ParNombreTraba = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParNombreTraba.ParameterName = "@cNombreTraba"; //--> Nombre del paramentro como está en el PRC
ParNombreTraba.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParNombreTraba.Size = 20; //--> Longuitud del campo
ParNombreTraba.Value = Trabajadores.CNombreTraba; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParNombreTraba); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//---//
SqlParameter ParcApellidos = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParcApellidos.ParameterName = "@cApellidos"; //--> Nombre del paramentro como está en el PRC
ParcApellidos.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParcApellidos.Size = 40; //--> Longuitud del campo
ParcApellidos.Value = Trabajadores.CApellidos; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParcApellidos); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//---//
SqlParameter ParccAcceso = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParccAcceso.ParameterName = "@cAcceso"; //--> Nombre del paramentro como está en el PRC
ParccAcceso.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParccAcceso.Size = 20; //--> Longuitud del campo
ParccAcceso.Value = Trabajadores.CAcceso; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParccAcceso); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//---//
SqlParameter ParPassword = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParPassword.ParameterName = "@Password"; //--> Nombre del paramentro como está en el PRC
ParPassword.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParPassword.Size = 20; //--> Longuitud del campo
ParPassword.Value = Trabajadores.Password; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParPassword); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//---//
SqlParameter ParUsuario = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParUsuario.ParameterName = "@cUsuario"; //--> Nombre del paramentro como está en el PRC
ParUsuario.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParUsuario.Size = 20; //--> Longuitud del campo
ParUsuario.Value = Trabajadores.CUsuario; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParUsuario); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//Ejecutamos nuestro comando, es decir estamos llamando al procedimiento almacenado para que se ejecute
rpta = SqlCmd.ExecuteNonQuery() == 1 ? "OK" : "NO se Actualizo el Registro";
}
catch (Exception ex)
{
rpta = ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(rpta);
}
//----------------------------------------------------------------------------------//
// BLOQUE DE METODOS PARA ALTAS, BAJAS, MODIFICACIONES .....
//----------------------------------------------------------------------------------//
//------------------- METODO ALTAS ------------------------------------------------------------------
//En los parametros que vamos a recibir en este metodo lo hacemos es
//instanciar la clase, de esta forma nos evitamos tener que estar poniendo campo a campo
//de los que se tengan que tener en cuenta, en este ejemplo son pocos campos pero si fueramos a tratar tabla
//donde hubiera muchos campos es un puto coñazo
public string Insertar(DTrabajadores Trabajadores)
{
string rpta = ""; //--> rpta - Variable para saber el valor de retorno
SqlConnection SqlCon = new SqlConnection(); //--> SqlCon - Variable de tipo Conexión SQL
try //--->Control de Errores
{
SqlCon.ConnectionString = Conexion.Cn; //--> Le digo a ConnectionString cual es nuestra conexión que tengo en la clase Conexión y en la variable Cn
SqlCon.Open(); //--> Abrimos la conexión
SqlCommand SqlCmd = new SqlCommand(); //--> SqlCmd - Variable de la clase SqlCommand para poder utilizar los comandos de SQL
SqlCmd.Connection = SqlCon; //--> Le pasamos la conexión.
SqlCmd.CommandText = "spInsertar_trabajador"; //--> Le decimos el nombre del Procedimiento a ejecutar
SqlCmd.CommandType = CommandType.StoredProcedure; //--> Le decimos que el tipo de comando es un PRC
//-->Descripción del campo IdTrabajador
//-----------------------------------------------------------------------------------
SqlParameter ParIdTrabajador = new SqlParameter(); //-> Esto es para "parametrizar", poder enviar parametros en consultas
ParIdTrabajador.ParameterName = "@idTrabajador"; //-> Nombre del parametro, este es el mismo que tengo puesto en el PRC
ParIdTrabajador.SqlDbType = SqlDbType.Int; //-> Tipo del campo
ParIdTrabajador.Direction = ParameterDirection.Output; //-> Este campo es Identity en la tabla por lo tanto indicar que es de salida Output
SqlCmd.Parameters.Add(ParIdTrabajador); //-> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//-->Descripción del campo cNombreTraba
//-----------------------------------------------------------------------------------
SqlParameter ParNombreTraba = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParNombreTraba.ParameterName = "@cNombreTraba"; //--> Nombre del paramentro como está en el PRC
ParNombreTraba.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParNombreTraba.Size = 20; //--> Longuitud del campo
ParNombreTraba.Value = Trabajadores.CNombreTraba; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParNombreTraba); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//-----------------------------------------------------------------------------------
SqlParameter ParcApellidos = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParcApellidos.ParameterName = "@cApellidos"; //--> Nombre del paramentro como está en el PRC
ParcApellidos.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParcApellidos.Size = 40; //--> Longuitud del campo
ParcApellidos.Value = Trabajadores.CApellidos; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParcApellidos); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//-----------------------------------------------------------------------------------
SqlParameter ParccAcceso = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParccAcceso.ParameterName = "@cAcceso"; //--> Nombre del paramentro como está en el PRC
ParccAcceso.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParccAcceso.Size = 20; //--> Longuitud del campo
ParccAcceso.Value = Trabajadores.CAcceso; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParccAcceso); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//-----------------------------------------------------------------------------------
SqlParameter ParPassword = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParPassword.ParameterName = "@Password"; //--> Nombre del paramentro como está en el PRC
ParPassword.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParPassword.Size = 20; //--> Longuitud del campo
ParPassword.Value = Trabajadores.Password; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParPassword); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//-------------------------------------------------------------------------------------------------
SqlParameter ParUsuario = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParUsuario.ParameterName = "@cUsuario"; //--> Nombre del paramentro como está en el PRC
ParUsuario.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParUsuario.Size = 20; //--> Longuitud del campo
ParUsuario.Value = Trabajadores.CUsuario; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParUsuario); //--> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//-----------------------------------------------------------------------------------
//--> Ahora Ejecutamos nuestro comando (tipo TERNARIO), es decir estamos llamando al procedimiento almacenado para que se ejecute
// Controlamos el éxito de la operación con el valor retornado en la variable rpta
// if ( SqlCmd.ExecuteNonQuery() == 1 )
// {
// rpta = "OK";
// }
// : else
// {
// rpta "NO se Ingreso el Registro";
// }
rpta = SqlCmd.ExecuteNonQuery() == 1 ? "OK" : "NO se Ingreso el Registro";
}
catch (Exception ex)
{
rpta = ex.Message; //-->Mostramos el mensaje.
}
finally //--> el finally se ejecuta siempre tanto si hay error como si no lo hay, así que cerramos la conexión que ya sabemos como mucha memoria.
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(rpta);
}