public static DataTable Buscar(String parNombre_Buscado)
{
DCategoria categorias = new DCategoria();
categorias.Nombre_Buscado = parNombre_Buscado;
return categorias.Buscar(categorias);
}
//Método Insertar que llama al método insertar de la clase DCategoria de la CapaDatos:
public static string Insertat(string nombre, string descripcion)
{
DCategoria categoria = new DCategoria();
categoria.Nombre = nombre;
categoria.Descripcion = descripcion;
return categoria.Insertar(categoria);
}
//Método BuscarNombre
public DataTable BuscarNombre(DCategoria Categoria)
{
DataTable DtResultado = new DataTable("categoria");
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spbuscar_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParTextoBuscar = new SqlParameter();
ParTextoBuscar.ParameterName = "@textobuscar";
ParTextoBuscar.SqlDbType = SqlDbType.VarChar;
ParTextoBuscar.Size = 50;
ParTextoBuscar.Value = Categoria.TextoBuscar;
SqlCmd.Parameters.Add(ParTextoBuscar);
SqlDataAdapter SqlDat = new SqlDataAdapter(SqlCmd);
SqlDat.Fill(DtResultado);
}
catch (Exception ex)
{
DtResultado = null;
}
return DtResultado;
}
public static String Eliminar(int parId_Categoria)
{
DCategoria categorias = new DCategoria();
categorias.Id_Categoria = parId_Categoria;
return categorias.Eliminar(categorias);
}
//Método Insertar que llama al método Insertar de la clase DCategoría
//de la CapaDatos
public static string Insertar(string nombre, string descripcion)
{
DCategoria Obj = new DCategoria();
Obj.Nombre = nombre;
Obj.Descripcion = descripcion;
return Obj.Insertar(Obj);
}
public static String Insertar(String parNombre_Categoria, String parDescripcion)
{
DCategoria categorias = new DCategoria();
categorias.Nombre_Categoria = parNombre_Categoria;
categorias.Descripcion = parDescripcion;
return categorias.Insertar(categorias);
}
//Método Editar que llama al método Editar de la clase DCategoría de la capaDatos:
public static string Editar(int iNCategoria, string nombre, string descripcion)
{
DCategoria categoria = new DCategoria();
categoria.IdCategoria = iNCategoria;
categoria.Nombre = nombre;
categoria.Descripcion = descripcion;
return categoria.Editar(categoria);
}
//Método Editar que llama al método Editar de la clase DCategoría
//de la CapaDatos
public static string Editar(int idcategoria,string nombre, string descripcion)
{
DCategoria Obj = new DCategoria();
Obj.Idcategoria = idcategoria;
Obj.Nombre = nombre;
Obj.Descripcion = descripcion;
return Obj.Editar(Obj);
}
public static String Editar(int parId_Categoria, String parNombre_Categoria, String parDescripcion)
{
DCategoria categorias = new DCategoria();
categorias.Id_Categoria = parId_Categoria;
categorias.Nombre_Categoria = parNombre_Categoria;
categorias.Descripcion = parDescripcion;
return categorias.Editar(categorias);
}
//Metodo Insertar
public string Insertar(DCategoria Categoria)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try //Capturador de errores
{
//Codigo
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Establecer el comando
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spinsertar_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdcategoria = new SqlParameter();
ParIdcategoria.ParameterName = "@idcategoria";
ParIdcategoria.SqlDbType = SqlDbType.Int;
ParIdcategoria.Direction = ParameterDirection.Output;
SqlCmd.Parameters.Add(ParIdcategoria);
SqlParameter ParNombre = new SqlParameter();
ParNombre.ParameterName = "@nombre";
ParNombre.SqlDbType = SqlDbType.VarChar;
ParNombre.Size = 50;
ParNombre.Value = Categoria.Nombre;
SqlCmd.Parameters.Add(ParNombre);
SqlParameter ParDescription = new SqlParameter();
ParDescription.ParameterName = "@descripcion";
ParDescription.SqlDbType = SqlDbType.VarChar;
ParDescription.Size = 256;
ParDescription.Value = Categoria.Descripcion;
SqlCmd.Parameters.Add(ParDescription);
//Ejecutamos nuestro comando
rpta = SqlCmd.ExecuteNonQuery() == 1 ? "OK" : "No se ingreso el Registro";
}
catch(Exception ex)
{
rpta = ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open) SqlCon.Close();
}
return rpta;
}
public string Editar(DCategoria Categoria)
{
string Rpta = "";
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spModificarCategoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter parIdCategoria = new SqlParameter();
parIdCategoria.ParameterName = "@Id_Categoria";
parIdCategoria.SqlDbType = SqlDbType.Int;
parIdCategoria.Value = Categoria.Id_Categoria;
SqlCmd.Parameters.Add(parIdCategoria);
SqlParameter parNombre = new SqlParameter();
parNombre.ParameterName = "@nombre";
parNombre.SqlDbType = SqlDbType.VarChar;
parNombre.Size = 50;
parNombre.Value = Categoria.Nombre;
SqlCmd.Parameters.Add(parNombre);
SqlParameter parDesc = new SqlParameter();
parDesc.ParameterName = "@descripcion";
parDesc.SqlDbType = SqlDbType.VarChar;
parDesc.Size = 255;
parDesc.Value = Categoria.Descripcion;
SqlCmd.Parameters.Add(parDesc);
Rpta = SqlCmd.ExecuteNonQuery() == 1 ? "Ok " : "No se edito";
}
catch (Exception ex)
{
Rpta = ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(Rpta);
}
// metodo eliminar
public string Eliminar(DCategoria categoria)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
// conexion
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
// comandos
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "speliminar_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
// parametros
SqlParameter ParIdCategoria = new SqlParameter();
ParIdCategoria.ParameterName = "@idcategoria";
ParIdCategoria.Value = categoria.Idcategoria;
ParIdCategoria.SqlDbType = SqlDbType.Int;
SqlCmd.Parameters.Add(ParIdCategoria);
// ejecutar comando
// si se inserto valor -> ok else no se ingreso
rpta = SqlCmd.ExecuteNonQuery() == 1? "OK" : "No se Eliminó el registro";
}
catch (Exception ex)
{
// en caso de error asignar a la variable el error devuelto
rpta = ex.Message;
}
finally
{
// si la conexion esta abierta, cierrala
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(rpta);
}
//Metodo Editar
public string Editar(DCategoria Categoria)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
//Codigo
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Establecer el Comando
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "modificarCategoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdCategoria = new SqlParameter();
ParIdCategoria.ParameterName = "@idCategoria";
ParIdCategoria.SqlDbType = SqlDbType.Int;
ParIdCategoria.Value = Categoria.IdCategoria;
SqlCmd.Parameters.Add(ParIdCategoria);
SqlParameter ParNombre = new SqlParameter();
ParNombre.ParameterName = "@nombre";
ParNombre.SqlDbType = SqlDbType.VarChar;
ParNombre.Size = 50;
ParNombre.Value = Categoria.Nombre;
SqlCmd.Parameters.Add(ParNombre);
//ejecutamos CMD
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 editar
public string Editar(DCategoria Categoria)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "speditar_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdCategoria = new SqlParameter();
ParIdCategoria.ParameterName = "@id";
ParIdCategoria.SqlDbType = SqlDbType.Int;
ParIdCategoria.Value = Categoria.IdCategoria;
SqlCmd.Parameters.Add(ParIdCategoria);
SqlParameter ParDescripcion = new SqlParameter();
ParDescripcion.ParameterName = "@descripcion";
ParDescripcion.SqlDbType = SqlDbType.VarChar;
ParDescripcion.Size = 100;
ParDescripcion.Value = Categoria.Descripcion;
SqlCmd.Parameters.Add(ParDescripcion);
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);
}
//***********************************************************************
//***********************************************************************
public DataTable Buscar(DCategoria parCategorias)
{
DataTable TablaDatos = new DataTable("Produccion.Categorias");
SqlConnection SqlConexion = new SqlConnection();
try
{
SqlConexion.ConnectionString = DConexion.cnDBEmpresa;
SqlConexion.Open();
SqlCommand SqlComando = new SqlCommand();
SqlComando.Connection = SqlConexion;
SqlComando.CommandText = "Produccion.CategoriaBuscar";
SqlComando.CommandType = CommandType.StoredProcedure;
SqlParameter ParNombre_Buscado = new SqlParameter();
ParNombre_Buscado.ParameterName = "@NombreBuscado";
ParNombre_Buscado.SqlDbType = SqlDbType.VarChar;
ParNombre_Buscado.Size = parCategorias.Nombre_Buscado.Length;
ParNombre_Buscado.Value = parCategorias.Nombre_Buscado;
SqlComando.Parameters.Add(ParNombre_Buscado);
SqlDataAdapter SqlAdaptadorDatos = new SqlDataAdapter(SqlComando);
SqlAdaptadorDatos.Fill(TablaDatos);
}
catch (Exception ex)
{
TablaDatos = null;
throw new Exception("Error al intentar ejecutar el procedimiento almacenado Produccion.BuscarCategoria. " + ex.Message, ex);
}
finally
{
if (SqlConexion.State == ConnectionState.Open)
{
SqlConexion.Close();
}
}
return(TablaDatos);
}
//***********************************************************************
//***********************************************************************
public DataTable Buscar(DCategoria parCategorias)
{
DataTable TablaDatos = new DataTable("Produccion.Categorias");
SqlConnection SqlConexion = new SqlConnection();
try
{
SqlConexion.ConnectionString = DConexion.cnDBEmpresa;
SqlConexion.Open();
SqlCommand SqlComando = new SqlCommand();
SqlComando.Connection = SqlConexion;
SqlComando.CommandText = "Produccion.CategoriaBuscar";
SqlComando.CommandType = CommandType.StoredProcedure;
SqlParameter ParNombre_Buscado = new SqlParameter();
ParNombre_Buscado.ParameterName = "@NombreBuscado";
ParNombre_Buscado.SqlDbType = SqlDbType.VarChar;
ParNombre_Buscado.Size = parCategorias.Nombre_Buscado.Length;
ParNombre_Buscado.Value = parCategorias.Nombre_Buscado;
SqlComando.Parameters.Add(ParNombre_Buscado);
SqlDataAdapter SqlAdaptadorDatos = new SqlDataAdapter(SqlComando);
SqlAdaptadorDatos.Fill(TablaDatos);
}
catch (Exception ex)
{
TablaDatos = null;
throw new Exception("Error al intentar ejecutar el procedimiento almacenado Produccion.BuscarCategoria. " + ex.Message, ex);
}
finally
{
if (SqlConexion.State == ConnectionState.Open)
{
SqlConexion.Close();
}
}
return TablaDatos;
}
public string Eliminar(DCategoria Categoria)
{
string rpta = "";
SqlConnection Sqlconexion = new SqlConnection();
try
{
//abrir conexion
Sqlconexion.ConnectionString = Conexion.Conectar;
Sqlconexion.Open();
//conexion al procedimiento almacenado
SqlCommand sqlcmd = new SqlCommand();
sqlcmd.Connection = Sqlconexion;
sqlcmd.CommandText = "Categoria_Eliminar";
sqlcmd.CommandType = CommandType.StoredProcedure;
//conexion con variables del SP
SqlParameter parCat_id = new SqlParameter();
parCat_id.ParameterName = "@Cat_id";
parCat_id.SqlDbType = SqlDbType.Int;
parCat_id.Value = Categoria.Cat_id;
sqlcmd.Parameters.Add(parCat_id);
//conexion nombre
rpta = sqlcmd.ExecuteNonQuery() == 1 ? "OK" : "NO SE ELIMINO EL REGISTRO";
}
catch (Exception ex)
{
rpta = ex.Message;
}
finally
{
if (Sqlconexion.State == ConnectionState.Open)
{
Sqlconexion.Close();
Sqlconexion.Dispose();
}
}
return(rpta);
}
//Metodo Eliminar
public string Eliminar(DCategoria Categoria)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
//Codigo
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Establecer el comando
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "speliminar_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdcategoria = new SqlParameter();
ParIdcategoria.ParameterName = "@idcategoria";
ParIdcategoria.SqlDbType = SqlDbType.Int;
ParIdcategoria.Value = Categoria.Idcategoria;
SqlCmd.Parameters.Add(ParIdcategoria);
//Ejecutamos nuestro comando
rpta = SqlCmd.ExecuteNonQuery() == 1 ? "OK" : "No se Elimino ningun registro";
}
catch (Exception ex)
{
rpta = ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(rpta);
}
//Método Insertar Categoría: es publico para que se pueda comunicar con las demas capas...
public string Insertar(DCategoria categoria)
{
string respuesta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Establecer el Comando:
SqlCommand cmd = new SqlCommand("spInsertarCategoria", SqlCon);
cmd.CommandType = CommandType.StoredProcedure;
//Parametros:
SqlParameter pIdCategoria = new SqlParameter("@IdCategoria", categoria.IdCategoria);
cmd.Parameters.Add(pIdCategoria);
SqlParameter pNombre = new SqlParameter("@Nombre", categoria.Nombre);
cmd.Parameters.Add(pNombre);
SqlParameter pDescripcion = new SqlParameter("@Descripción", categoria.Descripcion);
cmd.Parameters.Add(pDescripcion);
//Ejecutamos nuestro comando:
respuesta = cmd.ExecuteNonQuery() == 1 ? "OK" : "No se ingres el Resgistro.....";
}
catch (Exception ex)
{
respuesta = "ERROR: " + ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return respuesta;
}
// Metodo Buscar
public DataTable BuscarNombre(DCategoria Categoria)
{
// Declaro una variable del tipo Datatable para traer los resultados
DataTable DtResultado = new DataTable("categoria");
try
{
// PASO 1 Defino los parametros de conexion
MySqlConnection MyConexion = new MySqlConnection(Conexion.ConectionString);
// PASO 2 Creo el comando
MySqlCommand MyCommand = MyConexion.CreateCommand();
// PASO 3 Invoco el Stored Procedure
MyCommand.CommandText = "spbuscar_categoria";
// PASO 4 Digo que tipo de datos es el MyCommand
MyCommand.CommandType = CommandType.StoredProcedure;
// PASO 5 Defino los parametros de las variables
MySqlParameter ParTextoBuscar = new MySqlParameter();
ParTextoBuscar.ParameterName = "textobuscar";
ParTextoBuscar.MySqlDbType = MySqlDbType.VarChar;
ParTextoBuscar.Size = 50;
ParTextoBuscar.Value = Categoria.TextoBuscar;
MyCommand.Parameters.Add(ParTextoBuscar);
// PASO 6 Defino mi variable Data Adapter
MySqlDataAdapter MyData = new MySqlDataAdapter(MyCommand);
// PASO 7 lleno el data adapter
MyData.Fill(DtResultado);
}
catch (Exception)
{
DtResultado = null;
throw;
}
return(DtResultado);
}
// metodo eliminar
public bool Eliminar(DCategoria categoria)
{
int r = 0;
string cadena = "sp_eliminar_categoria";
SqlConnection cn = new SqlConnection();
try
{
// code here
cn.ConnectionString = Conexion.conectar;
cn.Open();
using (SqlCommand cmd = new SqlCommand(cadena, cn))
{
cmd.Parameters.AddWithValue("@id", categoria.IdCategoria);
cmd.CommandType = CommandType.StoredProcedure;
r = cmd.ExecuteNonQuery();
if (r == 1)
{
return(true);
}
}
}
catch (Exception ex)
{
string error = ex.Message;
return(false);
throw;
}
finally
{
if (cn.State == ConnectionState.Open)
{
cn.Close();
}
}
return(false);
}
//Método Insertar Categoría: es publico para que se pueda comunicar con las demas capas...
public string Insertar(DCategoria categoria)
{
string respuesta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Establecer el Comando:
SqlCommand cmd = new SqlCommand("spInsertarCategoria", SqlCon);
cmd.CommandType = CommandType.StoredProcedure;
//Parametros:
SqlParameter pIdCategoria = new SqlParameter("@IdCategoria", categoria.IdCategoria);
cmd.Parameters.Add(pIdCategoria);
SqlParameter pNombre = new SqlParameter("@Nombre", categoria.Nombre);
cmd.Parameters.Add(pNombre);
SqlParameter pDescripcion = new SqlParameter("@Descripción", categoria.Descripcion);
cmd.Parameters.Add(pDescripcion);
//Ejecutamos nuestro comando:
respuesta = cmd.ExecuteNonQuery() == 1 ? "OK" : "No se ingres el Resgistro.....";
}
catch (Exception ex)
{
respuesta = "ERROR: " + ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(respuesta);
}
// metodo editar
public int Actualizar(DCategoria categoria)
{
int r = 0;
string cadena = "sp_modificar_categoria";
SqlConnection cn = new SqlConnection();
try
{
// code here
cn.ConnectionString = Conexion.conectar;
cn.Open();
using (SqlCommand cmd = new SqlCommand(cadena, cn))
{
cmd.Parameters.AddWithValue("@nombre", categoria.Nombre);
cmd.Parameters.AddWithValue("@descripcion", categoria.Descripcion);
cmd.Parameters.AddWithValue("@idcategoria", categoria.IdCategoria);
cmd.CommandType = CommandType.StoredProcedure;
r = cmd.ExecuteNonQuery();
}
}
catch (Exception ex)
{
string error = ex.Message;
return(r);
throw;
}
finally
{
if (cn.State == ConnectionState.Open)
{
cn.Close();
}
}
return(r);
}
public string Eliminar(DCategoria Categoria)
{
string rpta = "";
SqlConnection sqlCon = new SqlConnection();
try
{
sqlCon.ConnectionString = Conexion.cn;
sqlCon.Open();
//Comandos
SqlCommand sqlCmd = new SqlCommand();
sqlCmd.Connection = sqlCon;
sqlCmd.CommandText = "sp_eliminarCategoria";
sqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdCategoria = new SqlParameter();
ParIdCategoria.ParameterName = "@idCategoria";
ParIdCategoria.SqlDbType = SqlDbType.Int;
ParIdCategoria.Value = Categoria.IdCategoria;
sqlCmd.Parameters.Add(ParIdCategoria);
rpta = sqlCmd.ExecuteNonQuery() == 1 ? "OK" : "No se eliminó el Registro";
}
catch (Exception ex)
{
rpta = ex.Message;
}
finally
{
if (sqlCon.State == ConnectionState.Open)
{
sqlCon.Close();
}
}
return(rpta);
}
public string Insertar(DCategoria Categoria)
{
string rpta = "";
SqlConnection sqlCon = new SqlConnection();
try
{
sqlCon.ConnectionString = Conexion.cn;
sqlCon.Open();
//Comandos
SqlCommand sqlCmd = new SqlCommand();
sqlCmd.Connection = sqlCon;
sqlCmd.CommandText = "sp_insertarCategoria";
sqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdCategoria = new SqlParameter();
ParIdCategoria.ParameterName = "@idCategoria";
ParIdCategoria.SqlDbType = SqlDbType.Int;
ParIdCategoria.Direction = ParameterDirection.Output;
sqlCmd.Parameters.Add(ParIdCategoria);
SqlParameter ParNomCategoria = new SqlParameter();
ParNomCategoria.ParameterName = "@nomCategoria";
ParNomCategoria.SqlDbType = SqlDbType.VarChar;
ParNomCategoria.Size = 50;
ParNomCategoria.Value = Categoria.Nombre;
sqlCmd.Parameters.Add(ParNomCategoria);
SqlParameter ParDescCategoria = new SqlParameter();
ParDescCategoria.ParameterName = "@descrCategoria";
ParDescCategoria.SqlDbType = SqlDbType.VarChar;
ParDescCategoria.Size = 256;
ParDescCategoria.Value = Categoria.Descripcion;
sqlCmd.Parameters.Add(ParDescCategoria);
SqlParameter ParEstCategoria = new SqlParameter();
ParEstCategoria.ParameterName = "@estCategoria";
ParEstCategoria.SqlDbType = SqlDbType.Char;
ParEstCategoria.Size = 1;
ParEstCategoria.Value = Categoria.Estado;
sqlCmd.Parameters.Add(ParEstCategoria);
SqlParameter ParOrden = new SqlParameter();
ParOrden.ParameterName = "@orden";
ParOrden.SqlDbType = SqlDbType.Int;
ParOrden.Value = Categoria.Orden;;
sqlCmd.Parameters.Add(ParOrden);
rpta = sqlCmd.ExecuteNonQuery() == 1 ? "OK" : "No se ingresó el Registro";
}
catch (Exception ex)
{
rpta = ex.Message;
}
finally
{
if (sqlCon.State == ConnectionState.Open)
{
sqlCon.Close();
}
}
return(rpta);
}
//***********************************************************************
//***********************************************************************
public string Editar(DCategoria parCategorias)
{
string Respuesta = "";
SqlConnection SqlConexion = new SqlConnection();
try
{
SqlConexion.ConnectionString = DConexion.cnDBEmpresa;
SqlConexion.Open();
SqlCommand SqlComando = new SqlCommand();
SqlComando.Connection = SqlConexion;
SqlComando.CommandText = "Produccion.CategoriaEditar";
SqlComando.CommandType = CommandType.StoredProcedure;
SqlParameter ParId_Categoria = new SqlParameter();
ParId_Categoria.ParameterName = "@Id_Categoria";
ParId_Categoria.SqlDbType = SqlDbType.Int;
ParId_Categoria.Value = parCategorias.Id_Categoria;
SqlComando.Parameters.Add(ParId_Categoria);
SqlParameter ParNombre_Categoria = new SqlParameter();
ParNombre_Categoria.ParameterName = "@Nombre_Categoria";
ParNombre_Categoria.SqlDbType = SqlDbType.VarChar;
ParNombre_Categoria.Size = parCategorias.Nombre_Categoria.Length;
ParNombre_Categoria.Value = parCategorias.Nombre_Categoria;
SqlComando.Parameters.Add(ParNombre_Categoria);
SqlParameter ParDescripcion = new SqlParameter();
ParDescripcion.ParameterName = "@Descripcion";
ParDescripcion.SqlDbType = SqlDbType.VarChar;
ParDescripcion.Size = parCategorias.Descripcion.Length;
ParDescripcion.Value = parCategorias.Descripcion;
SqlComando.Parameters.Add(ParDescripcion);
SqlComando.ExecuteNonQuery();
Respuesta = "Y";
}
catch (SqlException ex)
{
if (ex.Number == 8152)
{
Respuesta = "Has introducido demasiados caracteres en uno de los campos.";
}
else if (ex.Number == 2627)
{
Respuesta = "Ya existe una categoría con ese Nombre.";
}
else if (ex.Number == 515)
{
Respuesta = "No puedes dejar el campo Nombre vacío.";
}
else
{
Respuesta = "Error al intentar ejecutar el procedimiento almacenado Produccion.EditarCategoria. " + ex.Message;
}
}
finally
{
if (SqlConexion.State == ConnectionState.Open)
{
SqlConexion.Close();
}
}
return(Respuesta);
}
//Método Eliminar
public string Eliminar(DCategoria categoria)
{
string respuesta = string.Empty;
SqlConnection SqlCon = new SqlConnection();
try
{
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
//Comando:
SqlCommand cmd = new SqlCommand("spEliminarCategoria", SqlCon);
cmd.CommandType = CommandType.StoredProcedure;
//parametros:
SqlParameter pIdCategoria = new SqlParameter("@IdCategoria", categoria.IdCategoria);
cmd.Parameters.Add(pIdCategoria);
respuesta = cmd.ExecuteNonQuery() == 1 ? "OK" : "NO Se Elimino el Registro.....";
}
catch (Exception ex)
{
respuesta = "ERROR: " + ex.Message;
}
finally
{
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return respuesta;
}
// METODOS
// Metodo Insertar
public string Insertar(DCategoria Categoria)
{
// Variable que devuelve la respuesta del resultado
string Rpta = "";
try
{
// PASO 1 Conexion
MySqlConnection MyConexion = new MySqlConnection(Conexion.ConectionString);
// PASO 2 Creo el comando de sentencia SQL
MySqlCommand MyCommand = MyConexion.CreateCommand();
// PASO 3 Paso los parametros de SQL al MySQLCommand
MyCommand.CommandText = "spinsertar_categoria";
// PASO 4 Indico al MyCommand que es del tipo Stored Procedure
MyCommand.CommandType = CommandType.StoredProcedure;
// PASO 5 Paso parametros de las variables al Stored Procedure
// IDCategoria
MySqlParameter ParIDCategoria = new MySqlParameter();
ParIDCategoria.ParameterName = "idcategoria";
//ParIDCategoria.DbType = MySqlDbType.Int32;
ParIDCategoria.Direction = ParameterDirection.Output;
MyCommand.Parameters.Add(ParIDCategoria);
// Nombre
MySqlParameter ParNombre = new MySqlParameter();
ParNombre.ParameterName = "nombre";
//ParIDCategoria.DbType = MySqlDbType.Int32;
ParNombre.Size = 50;
ParNombre.Value = Categoria.Nombre;
ParNombre.Direction = ParameterDirection.Input;
MyCommand.Parameters.Add(ParNombre);
// Descripcion
MySqlParameter ParDescripcion = new MySqlParameter();
ParDescripcion.ParameterName = "descripcion";
//ParIDCategoria.DbType = MySqlDbType.Int32;
ParDescripcion.Size = 250;
ParDescripcion.Value = Categoria.Descripcion;
ParDescripcion.Direction = ParameterDirection.Input;
MyCommand.Parameters.Add(ParDescripcion);
// PASO 6 Ejecutamos el MyCommand
Rpta = MyCommand.ExecuteNonQuery() == 1? "OK":"No se ingreso el registro...";
// Cierro la conexion (si persiste abierta)
if (MyConexion.State == ConnectionState.Open)
{
MyConexion.Close();
}
}
catch (Exception ex)
{
Rpta = ex.Message;
throw;
}
finally
{
}
return(Rpta);
}
//***********************************************************************
//***********************************************************************
public string Insertar(DCategoria parCategorias)
{
string Respuesta = "";
SqlConnection SqlConexion = new SqlConnection();
try
{
SqlConexion.ConnectionString = DConexion.cnDBEmpresa;
SqlConexion.Open();
SqlCommand SqlComando = new SqlCommand();
SqlComando.Connection = SqlConexion;
SqlComando.CommandText = "Produccion.CategoriaInsertar";
SqlComando.CommandType = CommandType.StoredProcedure;
SqlParameter ParNombre_Categoria = new SqlParameter();
ParNombre_Categoria.ParameterName = "@Nombre_Categoria";
ParNombre_Categoria.SqlDbType = SqlDbType.VarChar;
ParNombre_Categoria.Size = parCategorias.Nombre_Categoria.Length;
ParNombre_Categoria.Value = parCategorias.Nombre_Categoria;
SqlComando.Parameters.Add(ParNombre_Categoria);
SqlParameter ParDescripcion = new SqlParameter();
ParDescripcion.ParameterName = "@Descripcion";
ParDescripcion.SqlDbType = SqlDbType.VarChar;
ParDescripcion.Size = parCategorias.Descripcion.Length;
ParDescripcion.Value = parCategorias.Descripcion;
SqlComando.Parameters.Add(ParDescripcion);
SqlComando.ExecuteNonQuery();
Respuesta = "Y";
}
catch (SqlException ex)
{
if (ex.Number == 8152)
{
Respuesta = "Has introducido demasiados caracteres en uno de los campos.";
}
else if (ex.Number == 2627)
{
Respuesta = "Ya existe una categoría con ese Nombre.";
}
else if (ex.Number == 515)
{
Respuesta = "No puedes dejar el campo Nombre vacío.";
}
else
{
Respuesta = "Error al intentar ejecutar el procedimiento almacenado Produccion.InsertarCategoria. " + ex.Message;
}
}
finally
{
if (SqlConexion.State == ConnectionState.Open)
{
SqlConexion.Close();
}
}
return Respuesta;
}
//Método buscar Nombres de las Categoría:
public DataTable BuscarNombre(DCategoria categoria)
{
DataTable dataTableResultado = new DataTable("categoria");
SqlConnection sqlCon = new SqlConnection();
try
{
sqlCon.ConnectionString = Conexion.Cn;
sqlCon.Open();
//comando:
SqlCommand cmd = new SqlCommand("spBuscarCategoria", sqlCon);
cmd.CommandType = CommandType.StoredProcedure;
//parametros:
SqlParameter ptxtBuscar = new SqlParameter("@txtBuscar", categoria.TxtBuscar);
cmd.Parameters.Add(ptxtBuscar);
//DataAdaptar:
SqlDataAdapter Da = new SqlDataAdapter(cmd);
Da.Fill(dataTableResultado);
}
catch (Exception)
{
dataTableResultado = null;
}
sqlCon.Close();
return dataTableResultado;
}
//Metodo Editar
public string Editar(DCategoria Categoria)
{
}
//***********************************************************************
//***********************************************************************
public string Eliminar(DCategoria parCategorias)
{
string Respuesta = "";
SqlConnection SqlConexion = new SqlConnection();
try
{
SqlConexion.ConnectionString = DConexion.cnDBEmpresa;
SqlConexion.Open();
SqlCommand SqlComando = new SqlCommand();
SqlComando.Connection = SqlConexion;
SqlComando.CommandText = "Produccion.CategoriaEliminar";
SqlComando.CommandType = CommandType.StoredProcedure;
SqlParameter ParId_Categoria = new SqlParameter();
ParId_Categoria.ParameterName = "@Id_Categoria";
ParId_Categoria.SqlDbType = SqlDbType.Int;
ParId_Categoria.Value = parCategorias.Id_Categoria;
SqlComando.Parameters.Add(ParId_Categoria);
SqlComando.ExecuteNonQuery();
Respuesta = "Y";
}
catch (SqlException ex)
{
if (ex.Number == 547)
{
Respuesta = "No puedes eliminar una categoría que cuenta con Productos. Debes eliminar o actualizar sus Productos antes de eliminar la categoría.";
}
else
{
Respuesta = "Error al intentar ejecutar el procedimiento almacenado Produccion.EliminarCategoria. " + ex.Message;
}
}
finally
{
if (SqlConexion.State == ConnectionState.Open)
{
SqlConexion.Close();
}
}
return Respuesta;
}
//Metodo Eliminar
public string Eliminar(DCategoria Categoria)
{
}
//Metodo BuscarNombre
public DataTable BuscarNombre(DCategoria Categoria)
{
}
//Método Eliminar
public string Eliminar(DCategoria Categoria)
{
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_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
SqlParameter ParIdcategoria = new SqlParameter();
ParIdcategoria.ParameterName = "@idcategoria";
ParIdcategoria.SqlDbType = SqlDbType.Int;
ParIdcategoria.Value = Categoria.Idcategoria;
SqlCmd.Parameters.Add(ParIdcategoria);
//Ejecutamos nuestro comando
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;
}
//Método BuscarNombre que llama al método BuscarNombre
//de la clase DCategoría de la CapaDatos
public static DataTable BuscarNombre(string textobuscar)
{
DCategoria Obj = new DCategoria();
Obj.TextoBuscar = textobuscar;
return Obj.BuscarNombre(Obj);
}
//Método Eliminar que llama al método Eliminar de la clase DCategoría
//de la CapaDatos
public static string Eliminar(int idcategoria)
{
DCategoria Obj = new DCategoria();
Obj.Idcategoria = idcategoria;
return Obj.Eliminar(Obj);
}
//metodos
//insertar
public string Insertar(DCategoria categoria)
{
//rpta = respuesta
string rpta = "";
SqlConnection slqCon = new SqlConnection();
try
{
//establecemos conexion con dbventas
slqCon.ConnectionString = Conexion.Cn;
slqCon.Open();
//establecer el comando
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = slqCon;
SqlCmd.CommandText = "spinsertar_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
//codigo para hacer posible el ingreso del parametro idcategoria
SqlParameter ParIdcategoria = new SqlParameter();
ParIdcategoria.ParameterName = "@idcategoria";
ParIdcategoria.SqlDbType = SqlDbType.Int;
ParIdcategoria.Direction = ParameterDirection.Output;
SqlCmd.Parameters.Add(ParIdcategoria);
//codigo para el ingreso del segundo parametro nombre
SqlParameter Parnombre = new SqlParameter();
Parnombre.ParameterName = "@nombre";
Parnombre.SqlDbType = SqlDbType.VarChar;
Parnombre.Size = 50;
Parnombre.Value = categoria.Nombre;
SqlCmd.Parameters.Add(Parnombre);
//codigo para el ingreso de una descripcion
SqlParameter Pardescripcion = new SqlParameter();
Pardescripcion.ParameterName = "@descripcion";
Pardescripcion.SqlDbType = SqlDbType.VarChar;
Pardescripcion.Size = 50;
Pardescripcion.Value = categoria.Descripcion;
SqlCmd.Parameters.Add(Pardescripcion);
//ejecutamos nuestros comandos
rpta = SqlCmd.ExecuteNonQuery() == 1 ? "OK" : "No se ingreso el registro ";
}
catch (Exception ex)
{
rpta = ex.Message;
}
finally
{
if (slqCon.State == ConnectionState.Open)
{
slqCon.Close();
}
}
return(rpta);
}
//Método Eliminar que llama al método Eliminar de la clase DCategoria de la CapaDatos:
public static string Eliminar(int idCategoria)
{
DCategoria categoria = new DCategoria();
categoria.IdCategoria = idCategoria;
return categoria.Eliminar(categoria);
}
//Método BUscarNombre que llama al método BuscarNombre de la capa DCategoria de la CapaDATOS:
public static DataTable BuscarNombre(string nombre)
{
DCategoria categoria = new DCategoria();
categoria.TxtBuscar = nombre;
return categoria.BuscarNombre(categoria);
}
// metodo insertar
public string Insertar(DCategoria categoria)
{
string rpta = "";
SqlConnection SqlCon = new SqlConnection();
try
{
// conexion
SqlCon.ConnectionString = Conexion.Cn;
SqlCon.Open();
// comandos
// agregamos el nombre del metodo y sus parametros
SqlCommand SqlCmd = new SqlCommand();
SqlCmd.Connection = SqlCon;
SqlCmd.CommandText = "spinsertar_categoria";
SqlCmd.CommandType = CommandType.StoredProcedure;
// parametros
SqlParameter ParIdCategoria = new SqlParameter();
ParIdCategoria.ParameterName = "@idcategoria";
ParIdCategoria.SqlDbType = SqlDbType.Int;
ParIdCategoria.Direction = ParameterDirection.Output;
SqlCmd.Parameters.Add(ParIdCategoria);
SqlParameter ParNombre = new SqlParameter();
ParNombre.ParameterName = "@nombre";
ParNombre.SqlDbType = SqlDbType.VarChar;
ParNombre.Size = 50;
// pasar el valor del nombre
ParNombre.Value = categoria.Nombre;
SqlCmd.Parameters.Add(ParNombre);
SqlParameter ParDescripcion = new SqlParameter();
ParDescripcion.ParameterName = "@descripcion";
ParDescripcion.SqlDbType = SqlDbType.VarChar;
ParDescripcion.Size = 256;
// pasar el valor del nombre
ParDescripcion.Value = categoria.Descripcion;
SqlCmd.Parameters.Add(ParDescripcion);
// ejecutar comando
// si se inserto valor -> ok else no se ingreso
rpta = SqlCmd.ExecuteNonQuery() == 1? "OK" : "No se Actualizo el registro";
}
catch (Exception ex)
{
// en caso de error asignar a la variable el error devuelto
rpta = ex.Message;
}
finally
{
// si la conexion esta abierta, cierrala
if (SqlCon.State == ConnectionState.Open)
{
SqlCon.Close();
}
}
return(rpta);
}