Omniauth fornece ganchos simples à API do gráfico do Facebook?

Question

Estou trabalhando na integração da Omniauth ao meu novo aplicativo no Facebook e estou analisando a documentação bastante escassa para entender se ele fornece maneiras simples de acessar a API do gráfico ... Estou passando de Koala, o que foi bem simples.

Alguém já usou Omniauth para isso? Quero tirar fotos dos álbuns dos usuários e classificar e obter os URLs exclusivos para eles.

Answer 1

Então, eu não consegui fazer com que o FB_GRAPH funcionasse corretamente - ainda sou um noob, tendo sido um desenvolvedor de rubi no Rails por um total de 8 a 10 semanas e, portanto, não tenho um instinto para o que deve ser um problema óbvio para outras pessoas.

No entanto, encontrei esta ótima postagem de blog que descreve um cliente simples do Facebook e mostra claramente como tudo se une. Encontrei um problema com ele pegando o objeto ME/Picture, pois o Facebook retorna um HTTP302 e não HTTP200, mas isso foi facilmente contatado com a ajuda do autor. Confira: http://bnerd.de/misc/ruby-write-basic-lient-for--facebook-graph-api/

Agora estou usando omniauth pela simplicidade da interação de login/assinatura com base neste passo a passo: blog.railsrumble.com/blog/2010/10/08/intridea-omniauth e com o token que recebo daquele que estou usando este simples FBClient da referência Bnerd acima para acessar a API do gráfico. Espero que o que encontrei ajude os outros.

... Aqui está minha versão do código de Bnerd e funcionou para mim:

    class FBClient

      def initialize(app, access_token = nil)
        @app = app
        @access_token = access_token
      end

      # request permission(s) from user
      def request(perms)
        #create a random verifier to identify user on fb callback
        verifier = (0...10).map{65.+(rand(25)).chr}.join
        uri = "https://graph.facebook.com/oauth/authorize?client_id=#{@app.app_id}&redirect_uri=#{@app.connect_url}?verifier=#{verifier}&scope=#{perms}"

        request = { :verifier => verifier, :uri => uri }
        return request

      end

      def connect(code, verifier)

        uri = URI.parse("https://graph.facebook.com/oauth/access_token?client_id=#{@app.app_id}&redirect_uri=#{@app.connect_url}?verifier=#{verifier}&client_secret=#{@app.secret}&code=#{CGI::escape(code)}")
        http = Net::HTTP.new(uri.host, uri.port)
        http.use_ssl = true

        request = Net::HTTP::Get.new(uri.path + "?" + uri.query)
        response = http.request(request)     
        data = response.body

        return data.split("=")[1]
      end

      # get, post
      def get(path, params = nil)
        uri = URI.parse("https://graph.facebook.com/" + path)
        http = Net::HTTP.new(uri.host, uri.port)
        http.use_ssl = true

        if params.nil?
          params = Hash.new
        end

        if params["access_token"].nil? 
          params["access_token"] = @access_token unless @access_token.nil?
        end

        request = Net::HTTP::Get.new(uri.path) 
        request.set_form_data( params )
        request = Net::HTTP::Get.new(uri.path + "?" + request.body)

        return response = http.request(request)
      end

      def post(path, params = nil)
        uri = URI.parse("https://graph.facebook.com/" + path)
        http = Net::HTTP.new(uri.host, uri.port)
        http.use_ssl = true        

        if params.nil?
          params = Hash.new
        end

        if params[:access_token].nil?
          params[:access_token] = @access_token unless @access_token.nil?
        end

        request = Net::HTTP::Post.new(uri.path) 
        request.set_form_data( params )
        request = Net::HTTP::Post.new(uri.path + "?" + request.body)

        response = http.request(request)
        response.code == "200" ? feed = JSON.parse(response.body) : raise("Sorry, an error occured. #{response.body}")
        return feed
      end
    end

Tenho certeza de que alguém mais experiente do que poderia melhorar isso - eu tinha cerca de 10 semanas de aprender Ruby (e minha primeira programação desde Fortran e Pascal na universidade no início dos anos 90!).

Answer 2

Eu finalmente descobri:

1) Incluir esta jóia

2) Use a jóia:

user = FbGraph::User.new('me', :access_token => session[:omniauth]["credentials"]["token"])

user.fetch

3) Recupere suas informaçõesuser.name

Lembre -se de que você pode obter qualquer coisa daqui ttp: //developers.facebook.com/docs/reference/api/user

Answer 3

Outra boa opção é Koala: https://github.com/arsduo/koala

Se você está apenas usando o Facebook, o Koala tem seu próprio suporte da OAuth. Também funciona bem com Omniauth. Para usá -los juntos, configure Omniauth de acordo com este Railscast:http://railscasts.com/episodes/235-omniauth-part-1

Em seguida, adicione uma coluna 'token' à tabela 'Autenticações' e quaisquer métodos de suporte para recuperar tokens. Quando o aplicativo precisar interagir com o Facebook, deixe Koala pegar o token e fazer suas coisas. Em um controlador:

if @token = current_user.facebook_token
  @graph = Koala::Facebook::GraphAPI.new(@token)
  @friends = @graph.get_connections("me", "friends")
end

Answer 4

Primeiro, eu iria para fb_graph, basta comparar:

com Koala:

graph = Koala::Facebook::GraphAPI.new OAUTH_ACCESS_TOKEN
friends = graph.get_connections("me", "friends")
graph.put_object("me", "feed", :message => "I am writing on my wall!")

com fb_graph:

me = FbGraph::User.me OAUTH_ACCESS_TOKEN
my_friends = me.friends
me.feed! :message => "I am writing on my wall!"

Ao usar Omniauth, todo usuário tem muitas autorizações (Facebook, Twitter, ...)

Para cada autorização do usuário, você deve armazenar o OAuth símbolo Isso é devolvido no seu hash de retorno de chamada OAuth.

auth = Authorization.create!(:user => user,
                             :uid =>      hash['uid'],
                             :provider => hash['provider'],
                             :token =>    hash['credentials']['token'])

Então, onde quer que você queira acessar álbuns e fotos, faça algo assim:

class User
  ...
  has_many :authorizations
  ...
  def grap_facebook_albums
    facebook = authorizations.where(:provider => :facebook).first
    fb_user = ::FbGraph::User.fetch facebook.uid, :access_token => facebook.token
    fb_albums = fb_user.albums
  end
  ...
end

Answer 5

Eu também tive problemas para obter a solução Devise+Omniauth para funcionar. Eu tive que problemas:

1. O cookie da sessão não armazenou o token de autenticação do Facebook necessário para inicializar FB_GRAPH e KOALA.
2. Não consegui inicializar o FB_GRAPH depois de fazer o token de autenticação do Facebook (mas fiz o coala trabalhar após algum trabalho).

Eu resolvi #1 inserindo 'sessão [: omniauth] = omniauth' no método Create do autentications_controller.rb.

Eu resolvi #2 usando Koala. Parece que o fb_graph requer oauth2, e o Devise Omniauth integração usa oauth. Koala trabalha perfeitamente com o token de autenticação do Facebook armazenado pela sessão [: omniauth] ["credenciais"] ["token"].

Você inicializa o coala assim:
- @fbprofile = koala :: facebook :: graphapi.new (sessão [: omniauth] ["credenciais"] ["token"])

Answer 6

Eu certifiquei -me de que OAuth e OAuth2 estivessem desinstalados e depois instalei oauth2. Parece que agora Omniauth e FB_Graph estão funcionando ... mas provavelmente precisam testá -lo mais.