omniauth 0.2.4 → 0.2.5

data/oa-oauth/lib/omniauth/strategies/netflix.rb

@@ -0,0 +1,65 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Netflix via OAuth and retrieve basic user information.
+    # Usage:
+    #    use OmniAuth::Strategies::Netflix, 'consumerkey', 'consumersecret'
+    #
+    class Netflix < OmniAuth::Strategies::OAuth
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        opts = {
+          :site               => 'http://api.netflix.com',
+          :request_token_path => "/oauth/request_token",
+          :access_token_path  => "/oauth/access_token",
+          :authorize_url      => "https://api-user.netflix.com/oauth/login"
+        }
+        super(app, :netflix, consumer_key, consumer_secret, opts, options, &block)
+      end
+
+      def request_phase
+        request_token = consumer.get_request_token(:oauth_callback => callback_url)
+        session['oauth'] ||= {}
+        session['oauth'][name.to_s] = {'callback_confirmed' => request_token.callback_confirmed?, 'request_token' => request_token.token, 'request_secret' => request_token.secret}
+        r = Rack::Response.new
+
+        if request_token.callback_confirmed?
+          r.redirect(request_token.authorize_url(
+            :oauth_consumer_key => consumer.key
+          ))
+        else
+          r.redirect(request_token.authorize_url(
+            :oauth_callback => callback_url,
+            :oauth_consumer_key => consumer.key
+          ))
+        end
+
+        r.finish
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'uid' => user_hash['user']['user_id'],
+          'user_info' => user_info,
+          'extra' => { 'user_hash' => user_hash['user'] }
+        })
+      end
+
+      def user_info
+        user = user_hash['user']
+        {
+          'nickname' => user['nickname'],
+          'first_name' => user['first_name'],
+          'last_name' => user['last_name'],
+          'name' => "#{user['first_name']} #{user['last_name']}"
+        }
+      end
+
+      def user_hash
+        @user_hash ||= MultiJson.decode(@access_token.get("http://api.netflix.com/users/#{@access_token.params[:user_id]}?output=json").body)
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/oauth.rb

@@ -0,0 +1,85 @@
+require 'multi_json'
+require 'oauth'
+require 'omniauth/oauth'
+
+module OmniAuth
+  module Strategies
+    class OAuth
+      include OmniAuth::Strategy
+
+      def initialize(app, name, consumer_key = nil, consumer_secret = nil, consumer_options = {}, options = {}, &block)
+        self.consumer_key = consumer_key
+        self.consumer_secret = consumer_secret
+        self.consumer_options = consumer_options
+        super
+        self.options[:open_timeout] ||= 30
+        self.options[:read_timeout] ||= 30
+        self.options[:authorize_params] = options[:authorize_params] || {}
+      end
+
+      def consumer
+        consumer = ::OAuth::Consumer.new(consumer_key, consumer_secret, consumer_options.merge(options[:client_options] || options[:consumer_options] || {}))
+        consumer.http.open_timeout = options[:open_timeout] if options[:open_timeout]
+        consumer.http.read_timeout = options[:read_timeout] if options[:read_timeout]
+        consumer
+      end
+
+      attr_reader :name
+      attr_accessor :consumer_key, :consumer_secret, :consumer_options
+
+      def request_phase
+        request_token = consumer.get_request_token(:oauth_callback => callback_url)
+        session['oauth'] ||= {}
+        session['oauth'][name.to_s] = {'callback_confirmed' => request_token.callback_confirmed?, 'request_token' => request_token.token, 'request_secret' => request_token.secret}
+        r = Rack::Response.new
+
+        if request_token.callback_confirmed?
+          r.redirect(request_token.authorize_url(options[:authorize_params]))
+        else
+          r.redirect(request_token.authorize_url(options[:authorize_params].merge(:oauth_callback => callback_url)))
+        end
+
+        r.finish
+      rescue ::Timeout::Error => e
+        fail!(:timeout, e)
+      end
+
+      def callback_phase
+        request_token = ::OAuth::RequestToken.new(consumer, session['oauth'][name.to_s].delete('request_token'), session['oauth'][name.to_s].delete('request_secret'))
+
+        opts = {}
+        if session['oauth'][name.to_s]['callback_confirmed']
+          opts[:oauth_verifier] = request['oauth_verifier']
+        else
+          opts[:oauth_callback] = callback_url
+        end
+
+        @access_token = request_token.get_access_token(opts)
+        super
+      rescue ::Timeout::Error => e
+        fail!(:timeout, e)
+      rescue ::Net::HTTPFatalError => e
+        fail!(:service_unavailable, e)
+      rescue ::OAuth::Unauthorized => e
+        fail!(:invalid_credentials, e)
+      rescue ::NoMethodError, ::MultiJson::DecodeError => e
+        fail!(:invalid_response, e)
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'credentials' => {
+            'token' => @access_token.token,
+            'secret' => @access_token.secret
+          }, 'extra' => {
+            'access_token' => @access_token
+          }
+        })
+      end
+
+      def unique_id
+        nil
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/oauth2.rb

@@ -0,0 +1,98 @@
+require 'cgi'
+require 'uri'
+require 'oauth2'
+require 'omniauth/oauth'
+
+module OmniAuth
+  module Strategies
+    # Authentication strategy for connecting with APIs constructed using
+    # the [OAuth 2.0 Specification](http://tools.ietf.org/html/draft-ietf-oauth-v2-10).
+    # You must generally register your application with the provider and
+    # utilize an application id and secret in order to authenticate using
+    # OAuth 2.0.
+    class OAuth2
+      include OmniAuth::Strategy
+
+      # The options passed in to the strategy.
+      attr_accessor :options
+      # The `OAuth2::Client` for this strategy.
+      attr_accessor :client_id, :client_secret, :client_options
+
+      # An error that is indicated in the OAuth 2.0 callback.
+      # This could be a `redirect_uri_mismatch` or other
+      class CallbackError < StandardError
+        attr_accessor :error, :error_reason, :error_uri
+
+        def initialize(error, error_reason=nil, error_uri=nil)
+          self.error = error
+          self.error_reason = error_reason
+          self.error_uri = error_uri
+        end
+      end
+
+      # Initialize a new OAuth 2.0 authentication provider.
+
+      # @param [Rack Application] app standard middleware application argument
+      # @param [String] name the name for this provider to be used in its URL, e.g. `/auth/name`
+      # @param [String] client_id the client/application ID of this provider
+      # @param [String] client_secret the client/application secret of this provider
+      # @param [Hash] options that will be passed through to the OAuth2::Client (see [oauth2 docs](http://rubydoc.info/gems/oauth2))
+      def initialize(app, name, client_id = nil, client_secret = nil, client_options = {}, options = {}, &block)
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.client_options = client_options
+        super
+      end
+
+      def client
+        ::OAuth2::Client.new(client_id, client_secret, client_options.merge(options[:client_options] || {}))
+      end
+
+      def callback_url
+        full_host + callback_path
+      end
+
+      protected
+
+      def request_phase
+        redirect client.web_server.authorize_url({:redirect_uri => callback_url}.merge(options))
+      end
+
+      def callback_phase
+        if request.params['error'] || request.params['error_reason']
+          raise CallbackError.new(request.params['error'], request.params['error_description'] || request.params['error_reason'], request.params['error_uri'])
+        end
+
+        @access_token = build_access_token
+
+        if @access_token.expires? && @access_token.expires_in <= 0
+          client.request(:post, client.access_token_url, {
+              'client_id' => client_id,
+              'grant_type' => 'refresh_token',
+              'client_secret' => client_secret,
+              'refresh_token' => @access_token.refresh_token
+            }.merge(options))
+          @access_token = client.web_server.get_access_token(verifier, {:redirect_uri => callback_url}.merge(options))
+        end
+
+        super
+      rescue ::OAuth2::HTTPError, ::OAuth2::AccessDenied, CallbackError => e
+        fail!(:invalid_credentials, e)
+      rescue ::MultiJson::DecodeError => e
+        fail!(:invalid_response, e)
+      end
+
+      def build_access_token
+        verifier = request.params['code']
+        client.web_server.get_access_token(verifier, {:redirect_uri => callback_url}.merge(options))
+      end
+
+      def auth_hash
+        credentials = {'token' => @access_token.token}
+        credentials.merge('refresh_token' => @access_token.refresh_token) if @access_token.expires?
+
+        OmniAuth::Utils.deep_merge(super, {'credentials' => credentials})
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/qzone.rb

@@ -0,0 +1,69 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to qzone (QQ) via OAuth and retrieve basic
+    # user information.
+    #
+    # Usage:
+    #
+    #    use OmniAuth::Strategies::Qzone, 'consumerkey', 'consumersecret'
+    #
+    class Qzone < OmniAuth::Strategies::OAuth
+      # Initialize the middleware
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        client_options = {
+          :site => 'http://openapi.qzone.qq.com',
+          :request_token_path => '/oauth/qzoneoauth_request_token',
+          :access_token_path  => '/oauth/qzoneoauth_access_token',
+          :authorize_path     => '/oauth/qzoneoauth_authorize',
+          :scheme             => :query_string,
+          :http_method        => :get
+        }
+
+        options[:authorize_params] = {:oauth_consumer_key => consumer_key}
+        super(app, :qzone, consumer_key, consumer_secret, client_options, options)
+      end
+
+      #HACK qzone is using a none-standard parameter oauth_overicode
+      def consumer_options
+        @consumer_options[:access_token_path] = '/oauth/qzoneoauth_access_token?oauth_vericode=' + request['oauth_vericode'] if request['oauth_vericode']
+        @consumer_options
+      end
+
+      def callback_phase
+        session['oauth'][name.to_s]['callback_confirmed'] = true
+        super
+      end
+
+      def auth_hash
+        ui = user_info
+        OmniAuth::Utils.deep_merge(super, {
+            'uid' => ui['uid'],
+            'user_info' => ui,
+            'extra' => {'user_hash' => user_hash}
+          })
+      end
+
+      def user_info
+        user_hash = self.user_hash
+        {
+          'uid' => @access_token.params[:openid],
+          'nickname' => user_hash['nickname'],
+          'name' =>  user_hash['nickname'],
+          'image' => user_hash['figureurl'],
+          'urls' => {
+            'figureurl_1' => user_hash['figureurl_1'],
+            'figureurl_2' => user_hash['figureurl_2'],
+          }
+        }
+      end
+
+      def user_hash
+        @user_hash ||= MultiJson.decode(@access_token.get("/user/get_user_info?format=json&openid=#{@access_token.params[:openid]}").body)
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/rdio.rb

@@ -0,0 +1,45 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    #
+    # Authenticate to Rdio via OAuth and retrieve basic user information.
+    # Usage:
+    #    use OmniAuth::Strategies::Rdio, 'consumerkey', 'consumersecret'
+    #
+    class Rdio < OmniAuth::Strategies::OAuth
+      def initialize(app, consumer_key = nil, consumer_secret = nil, options = {}, &block)
+        opts = {
+          :site               => 'http://api.rdio.com',
+          :request_token_path => "/oauth/request_token",
+          :access_token_path  => "/oauth/access_token",
+          :authorize_url      => "https://www.rdio.com/oauth/authorize"
+        }
+        super(app, :rdio, consumer_key, consumer_secret, opts, options, &block)
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'uid'       => user_hash['key'],
+          'user_info' => user_info,
+          'extra'     => { 'user_hash' => user_hash }
+        })
+      end
+
+      def user_info
+        user = user_hash
+        {
+          'nickname'   => user['username'],
+          'first_name' => user['firstName'],
+          'last_name'  => user['lastName'],
+          'name'       => "#{user['firstName']} #{user['lastName']}"
+        }
+      end
+
+      def user_hash
+        @user_hash ||= MultiJson.decode(@access_token.post("http://api.rdio.com/1/", { :method => 'currentUser', :extras => 'username' }).body)['result']
+      end
+    end
+  end
+end

data/oa-oauth/lib/omniauth/strategies/renren.rb

@@ -0,0 +1,87 @@
+require 'omniauth/oauth'
+require 'multi_json'
+require 'digest/md5'
+require 'net/http'
+
+module OmniAuth
+  module Strategies
+    # Authenticate to Renren utilizing OAuth 2.0 and retrieve
+    # basic user information.
+    #
+    # @example Basic Usage
+    #   use OmniAuth::Strategies::Renren, 'client_id', 'client_secret'
+    class Renren < OAuth2
+      # @param [Rack Application] app standard middleware application parameter
+      # @param [String] client_id the application id as [registered on Renren](http://dev.renren.com/)
+      # @param [String] client_secret the application secret as registered on Renren
+      # @option options [String] :scope ('publish_feed,status_update') comma-separated extended permissions such as `publish_feed` and `status_update`
+      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
+        client_options = {
+          :site => "http://graph.renren.com/",
+          :authorize_url      => "/oauth/authorize",
+          :access_token_url   => "/oauth/token"
+        }
+
+        super(app, :renren, client_id, client_secret, client_options, options, &block)
+      end
+
+      def user_data
+        @data ||= MultiJson.decode(Net::HTTP.post_form(URI.parse('http://api.renren.com/restserver.do'), signed_params).body)[0]
+      end
+
+      def signed_params
+        params = {}
+        params[:api_key] = client.id
+        params[:method] = "users.getInfo"
+        params[:call_id] = Time.now.to_i
+        params[:format] = "json"
+        params[:v] = "1.0"
+        params[:uids] = session_key["user"]["id"]
+        params[:session_key] = session_key["renren_token"]["session_key"]
+        params[:sig] = Digest::MD5.hexdigest(params.map {|k,v| "#{k}=#{v}"}.sort.join("") + client.secret)
+        params
+      end
+
+      def session_key
+        @session_key ||= MultiJson.decode(@access_token.get('/renren_api/session_key'))
+      end
+
+      def request_phase
+        options[:scope] ||= "publish_feed"
+        super
+      end
+
+      def build_access_token
+        if renren_session.nil? || renrensession.empty?
+          super
+        else
+          @access_token = ::OAuth2::AccessToken.new(client, renren_session['access_token'])
+        end
+      end
+
+      def renren_session
+        session_cookie = request.cookies["rrs_#{client.id}"]
+        if session_cookie
+          @renren_session ||= Rack::Utils.parse_query(request.cookies["rrs_#{client.id}"].gsub('"', ''))
+        else
+          nil
+        end
+      end
+
+      def user_info
+        {
+          'name' => user_data["name"],
+          'image' => user_data["tinyurl"]
+        }
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(super, {
+          'uid' => user_data['uid'],
+          'user_info' => user_info,
+          'extra' => {'user_hash' => user_data}
+        })
+      end
+    end
+  end
+end