Exemplo n.º 1
0
 /// <summary>
 /// Busca el usuario
 /// </summary>
 /// <returns>retorna el usuario</returns>
 public bool BuscarUsuario(ref Usuario usuario)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         comando.CommandText = "SELECT usuario, rol from Usuarios where usuario like @usuario";
         comando.Parameters.AddWithValue("@usuario", "%" + usuario.User + "%");
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Usuarios");
         if (ds.Tables["Usuarios"].Rows.Count != 0)
         {
             usuario.User = ds.Tables["Usuarios"].Rows[0]["usuario"].ToString();
             usuario.Rol  = ds.Tables["Usuarios"].Rows[0]["rol"].ToString();
             comando.Connection.Close();
             return(true);
         }
         else
         {
             comando.Connection.Close();
             return(false);
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
         return(false);
     }
 }
Exemplo n.º 2
0
 public DataTable BuscarTiposDeProducto(TipoDeProducto tipoDeProducto)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         comando.CommandText = "SELECT idTipoDeProducto as codigo, descripcion, nombre from TipoDeProducto where nombre like @Nombre";
         comando.Parameters.AddWithValue("@Nombre", "%" + tipoDeProducto.Nombre + "%");
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "TipoDeProducto");
         if (ds.Tables["TipoDeProducto"].Rows.Count != 0)
         {
             DataTable tabla = ds.Tables["TipoDeProducto"];
             return(tabla);
         }
         else
         {
             comando.Connection.Close();
             return(new DataTable());
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
         return(new DataTable());
     }
 }
Exemplo n.º 3
0
        public static void ModificarProductosDeCatalogo(Catalogo catalogo)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                ClaseConexion.Conectar();
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                comando.Connection  = ClaseConexion.Conexion;
                comando.Transaction = comando.Connection.BeginTransaction();
                comando.CommandText = "DELETE FROM ProductosXCatalogo WHERE idCatalogo = @IdCatalogo;";
                comando.Parameters.AddWithValue("@IdCatalogo", catalogo.IdCatalogo);
                comando.ExecuteNonQuery();
                foreach (Producto producto in catalogo.Productos)
                {
                    producto.Catalogo = catalogo;
                    OrganizarCatalogo.RegistrarProductosEnCatalogoSeguro(producto, comando.Transaction, comando.Connection);
                }
                comando.Transaction.Commit();
                comando.Connection.Close();
            }
            catch (SqlException ex)
            {
                comando.Transaction.Rollback();
                comando.Connection.Close();
                throw new Exception();
            }
        }
Exemplo n.º 4
0
 /// <summary>
 /// Inicia session. Devuelve verdadero si el usuario inicio sesion
 /// </summary>
 /// <param name="usuario">clase usuario con la contraseña y el usuario</param>
 /// <returns>verdadero sise inicio sssion, falso si no</returns>
 public string IniciarSession(Usuario usuario)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         comando.CommandText = "SELECT rol from Usuarios where usuario like @usuario AND contraseña like @contraseña";
         comando.Parameters.AddWithValue("@usuario", usuario.User);
         comando.Parameters.AddWithValue("@contraseña", usuario.Contraseña);
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Usuarios");
         if (ds.Tables["Usuarios"].Rows.Count != 0)
         {
             string rol = ds.Tables["Usuarios"].Rows[0]["rol"].ToString();
             comando.Connection.Close();
             return(rol);
         }
         else
         {
             comando.Connection.Close();
             return("desconocido");
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
         return("desconocido");
     }
 }
 /// <summary>
 /// Busca los datos personales para el usuario
 /// </summary>
 /// <param name="usuario">usuario</param>
 public void BuscarPersona(ref Usuario usuario)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         comando.CommandText = "SELECT Nombre, Apellido, idPersona from Persona where idUsuario like @usuario";
         comando.Parameters.AddWithValue("@usuario", "%" + usuario.User + "%");
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Personas");
         if (ds.Tables["Personas"].Rows.Count != 0)
         {
             usuario.Persona          = new Persona();
             usuario.Persona.Nombre   = ds.Tables["Personas"].Rows[0]["Nombre"].ToString();
             usuario.Persona.Apellido = ds.Tables["Personas"].Rows[0]["Apellido"].ToString();
             usuario.Persona.Id       = Convert.ToInt32(ds.Tables["Personas"].Rows[0]["idPersona"].ToString());
             comando.Connection.Close();
         }
         else
         {
             comando.Connection.Close();
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
     }
 }
Exemplo n.º 6
0
        /// <summary>
        /// Registra un usuario con su nombre de usuario y su contraseña
        /// </summary>
        /// <param name="usuario">usario</param>
        /// <param name="contraseña">contraseña</param>
        public void RegistraUsuario(Usuario usuario)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                ClaseConexion.Conectar();
                OrganizarPersona organizarPersona = new OrganizarPersona();
                comando.Connection = ClaseConexion.Conexion;
                SqlTransaction transaccion = comando.Connection.BeginTransaction();
                comando.Transaction = transaccion;
                comando.CommandType = CommandType.Text;
                comando.CommandText = "INSERT INTO Usuarios (usuario, contraseña) VALUES(@usuario, @contraseña); ";
                comando.Parameters.AddWithValue("@usuario", usuario.User);
                comando.Parameters.AddWithValue("@contraseña", usuario.Contraseña);
                comando.ExecuteNonQuery();
                organizarPersona.RegistrarPersona(usuario, transaccion, comando.Connection);
            }
            catch (SqlException)
            {
                ClaseConexion.Conexion.Close();
                throw new Exception();
            }
        }
Exemplo n.º 7
0
        public void ModificarTipoDeProductoAModificar(TipoDeProducto tipoDeProducto)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                ClaseConexion.Conectar();
                comando.Connection  = ClaseConexion.Conexion;
                comando.CommandType = CommandType.Text;
                StringBuilder sQL = new StringBuilder();
                sQL.Append("UPDATE TipoDeProducto ");
                sQL.Append("SET nombre = @Nombre, descripcion = @Descripcion");
                sQL.Append(" WHERE idTipoDeProducto = @IdTipoDeProducto;");
                comando.CommandText = sQL.ToString();
                comando.Parameters.AddWithValue("@IdTipoDeProducto", tipoDeProducto.IdTipoDeProducto);
                comando.Parameters.AddWithValue("@Nombre", tipoDeProducto.Nombre);
                comando.Parameters.AddWithValue("@Descripcion", tipoDeProducto.Descripcion);
                comando.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                ClaseConexion.Conexion.Close();
                throw new Exception();
            }
        }
Exemplo n.º 8
0
 /// <summary>
 /// Busca un catalogo deternminado
 /// </summary>
 /// <param name="catalogo">Objeto de tipo Catalogo con los datos de un catalogo</param>
 public void BuscarCatalogo(ref Catalogo catalogo)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         comando.CommandText = "SELECT idCatalogo, anio, temporada, nombre from Catalogo where nombre = @Nombre";
         comando.Parameters.AddWithValue("@Nombre", catalogo.Nombre);
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Catalogo");
         if (ds.Tables["Catalogo"].Rows.Count != 0)
         {
             catalogo.IdCatalogo = Convert.ToInt32(ds.Tables["Catalogo"].Rows[0]["idCatalogo"].ToString());
             catalogo.Fecha      = Convert.ToDateTime(ds.Tables["Catalogo"].Rows[0]["anio"].ToString());
             catalogo.Temporada  = ds.Tables["Catalogo"].Rows[0]["temporada"].ToString();
             catalogo.Nombre     = ds.Tables["Catalogo"].Rows[0]["nombre"].ToString();
             comando.Connection.Close();
         }
         else
         {
             comando.Connection.Close();
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
     }
 }
Exemplo n.º 9
0
        /// <summary>
        /// Modifica los datos de un catalogo
        /// </summary>
        /// <param name="catalogo">Objeto de tipo de catalogo con los datos de un catalogo</param>
        public void ModificarCatalogos(Catalogo catalogo)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                ClaseConexion.Conectar();
                comando.Connection  = ClaseConexion.Conexion;
                comando.CommandType = CommandType.Text;
                StringBuilder sQL = new StringBuilder();
                sQL.Append("UPDATE Catalogo ");
                sQL.Append("SET temporada = @Temporada, nombre = @Nombre");
                sQL.Append(" WHERE idCatalogo = @IdCatalogo;");
                comando.CommandText = sQL.ToString();
                comando.Parameters.AddWithValue("@IdCatalogo", catalogo.IdCatalogo);
                comando.Parameters.AddWithValue("@Temporada", catalogo.Temporada);
                comando.Parameters.AddWithValue("@Nombre", catalogo.Nombre);
                comando.ExecuteNonQuery();
            }
            catch (SqlException ex)
            {
                ClaseConexion.Conexion.Close();
                throw new Exception();
            }
        }
Exemplo n.º 10
0
 public void BuscarTipoDeProducto(ref TipoDeProducto tipoDeProducto)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         comando.CommandText = "SELECT idTipoDeProducto, nombre, descripcion from TipoDeProducto where nombre like @Nombre";
         comando.Parameters.AddWithValue("@Nombre", "%" + tipoDeProducto.Nombre + "%");
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "TipoDeProducto");
         if (ds.Tables["TipoDeProducto"].Rows.Count != 0)
         {
             tipoDeProducto.Nombre           = ds.Tables["TipoDeProducto"].Rows[0]["nombre"].ToString();
             tipoDeProducto.Descripcion      = ds.Tables["TipoDeProducto"].Rows[0]["descripcion"].ToString();
             tipoDeProducto.IdTipoDeProducto = Convert.ToInt32(ds.Tables["TipoDeProducto"].Rows[0]["idTipoDeProducto"].ToString());
             comando.Connection.Close();
         }
         else
         {
             comando.Connection.Close();
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
     }
 }
        /// <summary>
        /// Registra un usuario con su nombre de usuario y su contraseña
        /// </summary>
        /// <param name="usuario">usario</param>
        /// <param name="contraseña">contraseña</param>
        public void RegistrarProducto(Producto producto)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                ClaseConexion.Conectar();
                OrganizarCatalogo organizarCatalogo = new OrganizarCatalogo();
                comando.Connection = ClaseConexion.Conexion;
                SqlTransaction transaccion = comando.Connection.BeginTransaction();
                comando.Transaction = transaccion;
                comando.CommandType = CommandType.Text;
                comando.CommandText = "INSERT INTO Producto (nombre, tipoProducto, imagen, precio) VALUES(@Nombre, @TipoProducto, @Imagen, @Precio); ";
                comando.Parameters.AddWithValue("@Nombre", producto.Nombre);
                comando.Parameters.AddWithValue("@TipoProducto", producto.TipoDeProducto.IdTipoDeProducto);
                comando.Parameters.AddWithValue("@Imagen", producto.Imagen);
                comando.Parameters.AddWithValue("@Precio", producto.Precio);
                comando.ExecuteNonQuery();
                comando.Transaction.Commit();
                comando.Connection.Close();
            }
            catch (SqlException ex)
            {
                comando.Transaction.Commit();
                ClaseConexion.Conexion.Close();
                throw new Exception();
            }
        }
 /// <summary>
 /// Metodo para buscar losproductos de un catalogo
 /// </summary>
 /// <param name="catalogo">catalogo</param>
 /// <returns>tabla con los  productos</returns>
 public DataTable BuscarProductosPorCatalogo(Catalogo catalogo)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         comando.CommandText = "SELECT Producto.idProducto as Codigo, Producto.nombre from Producto, ProductosXCatalogo where Producto.idProducto = ProductosXCatalogo.idProducto AND ProductosXCatalogo.idCatalogo = @IdCatalogo";
         comando.Parameters.AddWithValue("@IdCatalogo", catalogo.IdCatalogo);
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Productos");
         if (ds.Tables["Productos"].Rows.Count != 0)
         {
             DataTable tabla = ds.Tables["Productos"];
             return(tabla);
         }
         else
         {
             comando.Connection.Close();
             return(new DataTable());
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
         return(new DataTable());
     }
 }
Exemplo n.º 13
0
 /// <summary>
 /// Busca los catalogos segun un criterio de busqueda
 /// </summary>
 /// <param name="catalogo">Objeto de tipo de catalogo con los datos de un catalogo</param>
 /// <returns>Tabla los catalogos</returns>
 public DataTable BuscarCatalogos(Catalogo catalogo)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         StringBuilder sQL = new StringBuilder();
         sQL.Append("SELECT idCatalogo as codigo, anio, temporada, nombre from Catalogo ");
         if (!catalogo.Fecha.ToString().Equals("1/1/0001 00:00:00"))
         {
             sQL.Append("WHERE (nombre like @Nombre ");
             sQL.Append("AND anio = @Fecha); ");
             comando.Parameters.AddWithValue("@Nombre", "%" + catalogo.Nombre + "%");
             comando.Parameters.AddWithValue("@Fecha", catalogo.Fecha);
         }
         else
         {
             sQL.Append("WHERE nombre like @Nombre ");
             comando.Parameters.AddWithValue("@Nombre", "%" + catalogo.Nombre + "%");
         }
         comando.CommandText = sQL.ToString();
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Catalogo");
         if (ds.Tables["Catalogo"].Rows.Count != 0)
         {
             DataTable tabla = ds.Tables["Catalogo"];
             return(tabla);
         }
         else
         {
             comando.Connection.Close();
             return(new DataTable());
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
         return(new DataTable());
     }
 }
 /// <summary>
 /// Busca el producto
 /// </summary>
 /// <returns>retorna el usuario</returns>
 public void BuscarProducto(ref Producto producto)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         StringBuilder sQL = new StringBuilder();
         sQL.Append("SELECT idProducto, nombre, tipoProducto, imagen, precio FROM Producto ");
         sQL.Append("WHERE nombre LIKE @Nombre ");
         comando.CommandText = sQL.ToString();
         comando.Parameters.AddWithValue("@Nombre", "%" + producto.Nombre + "%");
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Producto");
         if (ds.Tables["Producto"].Rows.Count != 0)
         {
             producto.IdProducto     = Convert.ToInt32(ds.Tables["Producto"].Rows[0]["idProducto"].ToString());
             producto.Nombre         = ds.Tables["Producto"].Rows[0]["nombre"].ToString();
             producto.TipoDeProducto = new TipoDeProducto();
             producto.TipoDeProducto.IdTipoDeProducto = Convert.ToInt32(ds.Tables["Producto"].Rows[0]["tipoProducto"].ToString());
             producto.Precio = float.Parse(ds.Tables["Producto"].Rows[0]["precio"].ToString());
             if (ds.Tables["Producto"].Rows[0]["imagen"] != null)
             {
                 producto.Imagen = ds.Tables["Producto"].Rows[0]["imagen"].ToString();
             }
             else
             {
                 producto.Imagen = "";
             }
             comando.Connection.Close();
         }
         else
         {
             comando.Connection.Close();
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
     }
 }
Exemplo n.º 15
0
        public static void BorrarTipoDeProducto(TipoDeProducto tipoDeProducto)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                ClaseConexion.Conectar();
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                comando.Connection  = ClaseConexion.Conexion;
                comando.CommandText = "DELETE FROM TipoDeProducto WHERE idTipoDeProducto = @IdTipoDeProducto;";
                comando.Parameters.AddWithValue("@IdTipoDeProducto", tipoDeProducto.IdTipoDeProducto);
                comando.ExecuteNonQuery();
                comando.Connection.Close();
            }
            catch (SqlException ex)
            {
                comando.Connection.Close();
                throw new Exception();
            }
        }
        public static void BorrarPersona(Usuario usuario)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                ClaseConexion.Conectar();
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                comando.Connection = ClaseConexion.Conexion;
                SqlTransaction transaccion = comando.Connection.BeginTransaction();
                comando.Transaction = transaccion;
                comando.CommandText = "DELETE FROM Persona WHERE idPersona = @IdPersona;";
                comando.Parameters.AddWithValue("@IdPersona", usuario.Persona.Id);
                comando.ExecuteNonQuery();
                OrganizarUsuario.BorrarUsuario(usuario, transaccion, comando.Connection);
            }
            catch (SqlException ex)
            {
                comando.Connection.Close();
                throw new Exception();
            }
        }
Exemplo n.º 17
0
        /// <summary>
        /// Registra los tipos de producto
        /// </summary>
        /// <param name="usuario">usuario</param>
        /// <param name="transaccion">SQLTransaccion</param>
        /// <param name="conexion">conexion</param>
        public void RegistrarTipoDeProducto(TipoDeProducto tipoDeProducto)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                ClaseConexion.Conectar();
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                comando.Connection  = ClaseConexion.Conexion;
                comando.CommandType = CommandType.Text;
                comando.CommandText = "INSERT INTO TipoDeProducto (descripcion, nombre) VALUES(@Descripcion, @Nombre); ";
                comando.Parameters.AddWithValue("@Nombre", tipoDeProducto.Nombre);
                comando.Parameters.AddWithValue("@Descripcion", tipoDeProducto.Descripcion);
                comando.ExecuteNonQuery();
                comando.Connection.Close();
            }
            catch (SqlException ex)
            {
                comando.Transaction.Rollback();
                throw new Exception();
            }
        }
        public void BorrarProducto(Producto producto)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                ClaseConexion.Conectar();
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                comando.Connection = ClaseConexion.Conexion;
                SqlTransaction transaction = comando.Connection.BeginTransaction();
                comando.Transaction = transaction;
                comando.CommandText = "DELETE FROM Producto WHERE idProducto = @IdProducto;";
                comando.Parameters.AddWithValue("@IdProducto", producto.IdProducto);
                comando.ExecuteNonQuery();
                OrganizarCatalogo.BorrarProductoDeUnCatalogo(producto, comando.Transaction, comando.Connection);
                comando.Connection.Close();
            }
            catch (SqlException ex)
            {
                comando.Connection.Close();
                throw new Exception();
            }
        }
Exemplo n.º 19
0
        /// <summary>
        /// Registra los catalogos de los producto
        /// </summary>
        /// <param name="catalogo">Catalogo</param>
        public void RegistrarCatalogo(Catalogo catalogo)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                ClaseConexion.Conectar();
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                comando.Connection  = ClaseConexion.Conexion;
                comando.CommandType = CommandType.Text;
                comando.CommandText = "INSERT INTO Catalogo (anio, temporada, nombre) VALUES(@Fecha, @Temporada, @Nombre); ";
                CultureInfo cultura = new CultureInfo("en-US");
                comando.Parameters.AddWithValue("@Fecha", Convert.ToDateTime(catalogo.Fecha, cultura));
                comando.Parameters.AddWithValue("@Temporada", catalogo.Temporada);
                comando.Parameters.AddWithValue("@Nombre", catalogo.Nombre);
                comando.ExecuteNonQuery();
                comando.Connection.Close();
            }
            catch (SqlException ex)
            {
                comando.Transaction.Rollback();
                throw new Exception();
            }
        }
Exemplo n.º 20
0
        /// <summary>
        /// Modificar un usuario
        /// </summary>
        /// <param name="usuario">usario</param>
        public void ModificarUsuario(Usuario usuario)
        {
            SqlCommand comando = new SqlCommand();

            try
            {
                //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
                ClaseConexion.Conectar();
                OrganizarPersona organizarPersona = new OrganizarPersona();
                comando.Connection = ClaseConexion.Conexion;
                SqlTransaction transaccion = comando.Connection.BeginTransaction();
                comando.Transaction = transaccion;
                comando.CommandType = CommandType.Text;
                StringBuilder sQL = new StringBuilder();
                sQL.Append("UPDATE Usuarios ");
                sQL.Append("SET rol = 'Admin'");
                if (usuario.Contraseña != null)
                {
                    sQL.Append(" ,contraseña = @contraseña");
                }
                sQL.Append(" WHERE usuario = @usuario;");
                comando.CommandText = sQL.ToString();
                comando.Parameters.AddWithValue("@usuario", usuario.User);
                if (usuario.Contraseña != null)
                {
                    comando.Parameters.AddWithValue("@contraseña", usuario.Contraseña);
                }
                comando.ExecuteNonQuery();
                organizarPersona.ModificarPersona(usuario, transaccion, comando.Connection);
            }
            catch (SqlException ex)
            {
                ClaseConexion.Conexion.Close();
                throw new Exception();
            }
        }
 /// <summary>
 /// Busca los usuarios
 /// </summary>
 /// <returns>retorna los usuarios</returns>
 public DataTable BuscarProductos(Producto producto, float?precioDesde, float?precioHasta, string orden)
 {
     try
     {
         //Defino un SqlComand y llamo al metodo conectar para que se conecte y me devuelva la conexion
         SqlCommand comando = new SqlCommand();
         ClaseConexion.Conectar();
         comando.Connection  = ClaseConexion.Conexion;
         comando.CommandType = CommandType.Text;
         StringBuilder sQL = new StringBuilder();
         sQL.Append("SELECT p.idProducto as Codigo, p.nombre, p.precio, p.imagen from Producto p ");
         if (producto.Catalogo != null)
         {
             sQL.Append(" JOIN ProductosXCatalogo p1 ON p.idProducto = p1.idProducto ");
         }
         sQL.Append("where p.nombre like @Nombre ");
         comando.Parameters.AddWithValue("@Nombre", "%" + producto.Nombre + "%");
         if (producto.Catalogo != null)
         {
             sQL.Append("AND p1.idCatalogo = @IdCatalogo ");
             comando.Parameters.AddWithValue("@IdCatalogo", producto.Catalogo.IdCatalogo);
         }
         if (producto.TipoDeProducto != null)
         {
             sQL.Append("AND tipoProducto = @TipoDeProducto ");
             comando.Parameters.AddWithValue("@TipoDeProducto", producto.TipoDeProducto.IdTipoDeProducto);
         }
         if (precioDesde != null)
         {
             sQL.Append("AND precio >= @PrecioDesde ");
             comando.Parameters.AddWithValue("@PrecioDesde", precioDesde);
         }
         if (precioHasta != null)
         {
             sQL.Append("AND precio <= @PrecioHasta ");
             comando.Parameters.AddWithValue("@PrecioHasta", precioHasta);
         }
         if (orden != "")
         {
             sQL.Append("ORDER BY precio " + orden);
         }
         comando.CommandText = sQL.ToString();
         SqlDataAdapter da = new SqlDataAdapter(comando);
         DataSet        ds = new DataSet();
         da.Fill(ds, "Productos");
         if (ds.Tables["Productos"].Rows.Count != 0)
         {
             DataTable tabla = ds.Tables["Productos"];
             return(tabla);
         }
         else
         {
             comando.Connection.Close();
             return(new DataTable());
         }
     }
     catch (SqlException ex)
     {
         ClaseConexion.Conexion.Close();
         return(new DataTable());
     }
 }