public static DataTable Buscar(String parNombre_Buscado)
        {
            DCategoria categorias = new DCategoria();
            categorias.Nombre_Buscado = parNombre_Buscado;

            return categorias.Buscar(categorias);
        }
Exemple #2
0
 //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);
        }
Exemple #7
0
 //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);
        }
Exemple #10
0
        //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;
        }
Exemple #11
0
        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);
        }
Exemple #12
0
        // 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);
        }
Exemple #13
0
        //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);
        }
Exemple #14
0
        //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);
        }
Exemple #15
0
        //***********************************************************************
        //***********************************************************************

        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);
        }
Exemple #18
0
        //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);
        }
Exemple #19
0
        //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;
         }
Exemple #20
0
        // 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);
        }
Exemple #21
0
        // 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);
        }
Exemple #22
0
        //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);
        }
Exemple #23
0
        // 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);
        }
Exemple #24
0
        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);
        }
Exemple #25
0
        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);
        }
Exemple #26
0
        //***********************************************************************
        //***********************************************************************
        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);
        }
Exemple #27
0
        //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;
        }
Exemple #28
0
        // 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;
        }
Exemple #30
0
        //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;
        }
Exemple #31
0
 //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;
        }
Exemple #33
0
 //Metodo Eliminar
 public string Eliminar(DCategoria Categoria)
 {
 }
Exemple #34
0
 //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);
        }
Exemple #39
0
 //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);   
 }
Exemple #40
0
 //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);
  }
Exemple #41
0
        // 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);
        }