コード例 #1
0
        //-> 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);
        }
コード例 #2
0
        //-------------------    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);
        }
コード例 #3
0
        //-------------------    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);
        }
コード例 #4
0
        //-------------------    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);
        }
コード例 #5
0
        //----------------------------------------------------------------------------------//
        //         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);
        }