public DataTable BuscarNombre(DFamilias Familias)
{
DataTable DtResultado = new DataTable("Familias");
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spBuscar_Proveedor_num_documento";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParTextoBuscar = new SqlParameter();
ParTextoBuscar.ParameterName = "@textobuscar";
ParTextoBuscar.SqlDbType = SqlDbType.VarChar;
ParTextoBuscar.Size = 12;
ParTextoBuscar.Value = Familias.CTextoBuscar;
SqlCmd.Parameters.Add(ParTextoBuscar);
SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
SqlDat.Fill(DtResultado);
}
catch (Exception ex)
{
DtResultado = null;
}
return(DtResultado);
}
//------------------- METODO MODIFICAR/EDITAR -----------------------------------------------------------------
public string Editar(DFamilias Familias)
{
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_familia";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdCodFam = new SqlParameter();
ParIdCodFam.ParameterName = "@idCodFam"; //Nombre que tengo en el PCR
ParIdCodFam.SqlDbType = SqlDbType.Int;
ParIdCodFam.Value = Familias.IdCodFam; //Toma el valor de la propiedad
SqlCmd.Parameters.Add(ParIdCodFam);
SqlParameter ParNombreFamilia = new SqlParameter();
ParNombreFamilia.ParameterName = "@cNombreFamilia"; //Nombre que tengo en el PCR
ParNombreFamilia.SqlDbType = SqlDbType.VarChar;
ParNombreFamilia.Size = 50;
ParNombreFamilia.Value = Familias.CNombreFamilia;
SqlCmd.Parameters.Add(ParNombreFamilia);
//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);
}
//------------------- METODO BAJAS/ELIMINAR -----------------------------------------------------------------
public string Eliminar(DFamilias Familias)
{
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_familia";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdCodFam = new SqlParameter();
ParIdCodFam.ParameterName = "@idCodFam";
ParIdCodFam.SqlDbType = SqlDbType.Int;
ParIdCodFam.Value = Familias.IdCodFam;
SqlCmd.Parameters.Add(ParIdCodFam);
//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);
}
//----------------------------------------------------------------------------------//
// 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(DFamilias Familias)
{
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_familia"; //--> 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 idCodFam de la tabla Familias
//-----------------------------------------------------------------------------------
SqlParameter ParIdCodFam = new SqlParameter(); //-> Esto es para "parametrizar", poder enviar parametros en consultas
ParIdCodFam.ParameterName = "@idCodFam"; //-> Nombre del parametro, este es el mismo que tengo puesto en el PRC
ParIdCodFam.SqlDbType = SqlDbType.Int; //-> Tipo del campo
ParIdCodFam.Direction = ParameterDirection.Output; //-> Este campo es Identity por lo tanto indicar que es de salida Output
SqlCmd.Parameters.Add(ParIdCodFam); //-> Acción que tiene que llevar a cabo, AÑADIR en este caso con los parametros contenidos en ParNombre
//-->Descripción del campo cNombreFamilia de la tabla Familias
//-----------------------------------------------------------------------------------
SqlParameter ParNombreFamilia = new SqlParameter(); //--> Esto es para "parametrizar", poder enviar parametros en consultas
ParNombreFamilia.ParameterName = "@cNombreFamilia"; //--> Nombre del paramentro como está en el PRC
ParNombreFamilia.SqlDbType = SqlDbType.VarChar; //--> Tipo del campo.
ParNombreFamilia.Size = 50; //--> Longuitud del campo
ParNombreFamilia.Value = Familias.CNombreFamilia; //--> Aquí sí, le enviamos el valor que tenemos en la Propiedad OjO
SqlCmd.Parameters.Add(ParNombreFamilia); //--> 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 chupa mucha memoria.
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(rpta);
}
