oa-oauth 0.2.6 → 0.3.0.rc3

data/lib/omniauth/strategies/oauth2/salesforce.rb

@@ -0,0 +1,48 @@
+require 'omniauth/strategies/oauth2'
+
+module OmniAuth
+  module Strategies
+    class Salesforce < OmniAuth::Strategies::OAuth2
+      def initialize(app, client_id=nil, client_secret=nil, options={}, &block)
+        client_options = {
+          :authorize_url => 'https://login.salesforce.com/services/oauth2/authorize',
+          :token_url => 'https://login.salesforce.com/services/oauth2/token',
+        }
+        options.merge!(:response_type => 'code', :grant_type => 'authorization_code')
+        super(app, :salesforce, client_id, client_secret, client_options, options, &block)
+      end
+
+      def auth_hash
+        data = user_data
+        OmniAuth::Utils.deep_merge(
+          super, {
+            'uid' => @access_token['id'],
+            'credentials' => {
+              'issued_at' => @access_token['issued_at'],
+              'refresh_token' => @access_token.refresh_token,
+              'instance_url' => @access_token['instance_url'],
+              'signature' => @access_token['signature'],
+            },
+            'extra' => {
+              'user_hash' => data,
+            },
+            'user_info' => {
+              'email' => data['email'],
+              'name' => data['display_name'],
+            },
+          }
+        )
+      end
+
+      def user_data
+        @data ||= MultiJson.decode(@access_token.get(@access_token['id']))
+      rescue ::OAuth2::Error => e
+        if e.response.status == 302
+          @data ||= MultiJson.decode(@access_token.get(e.response.headers['location']))
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/omniauth/strategies/oauth2/sound_cloud.rb

@@ -0,0 +1,60 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    # Authenticate to SoundCloud via OAuth2 and retrieve basic
+    # user information.
+    #
+    # Usage:
+    #    use OmniAuth::Strategies::SoundCloud, 'consumerkey', 'consumersecret'
+    class SoundCloud < OmniAuth::Strategies::OAuth2
+      def initialize(app, consumer_key=nil, consumer_secret=nil, options={}, &block)
+        client_options = {
+          :site => 'https://api.soundcloud.com',
+          :authorize_url => 'https://soundcloud.com/connect',
+          :token_url => 'https://api.soundcloud.com/oauth2/token'
+        }
+        super(app, :soundcloud, consumer_key, consumer_secret, client_options, options, &block)
+      end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(
+          super, {
+            'uid' => user_hash['id'],
+            'user_info' => user_info,
+            'extra' => {
+              'user_hash' => user_hash,
+            }
+          }
+        )
+      end
+
+      def user_info
+        user_hash = self.user_hash
+        {
+          'name' => user_hash['full_name'],
+          'nickname' => user_hash['username'],
+          'location' => user_hash['city'],
+          'description' => user_hash['description'],
+          'image' => user_hash['avatar_url'],
+          'urls' => {
+            'Website' => user_hash['website'],
+          },
+        }
+      end
+
+      def user_hash
+        @user_hash ||= MultiJson.decode(@access_token.get('/me.json').body)
+      end
+
+      # OAuth2 by default uses 'Bearer %s' in the header
+      def build_access_token
+        access_token = super
+        access_token.options[:header_format] = "OAuth %s"
+        access_token
+      end
+
+    end
+  end
+end

data/lib/omniauth/strategies/{taobao.rb → oauth2/taobao.rb}

@@ -9,21 +9,31 @@ module OmniAuth
     # basic user information.
     #
     # @example Basic Usage
-    # use OmniAuth::Strategies::TB, 'client_id', 'client_secret'
-    class TB < OAuth2
+    # use OmniAuth::Strategies::TaoBao, 'client_id', 'client_secret'
+    class Taobao < OmniAuth::Strategies::OAuth2
       # @param [Rack Application] app standard middleware application parameter
       # @param [String] client_id the app key at taobao open platform
       # @param [String] client_secret  the app secret at taobao open platform
       # @option options [String]
 
-      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
+      def initialize(app, client_id=nil, client_secret=nil, options={}, &block)
         client_options = {
-          :site => "https://oauth.taobao.com/",
-          :authorize_url => "/authorize",
-          :access_token_url => "/token"
+          :authorize_url => 'https://oauth.taobao.com/authorize',
+          :token_url => 'https://oauth.taobao.com/token',
         }
+        super(app, :taobao, client_id, client_secret, client_options, options, &block)
+      end
 
-        super(app, :tb, client_id, client_secret, client_options, options, &block)
+      def auth_hash
+        OmniAuth::Utils.deep_merge(
+          super, {
+            'uid' => user_data['uid'],
+            'user_info' => user_info,
+            'extra' => {
+              'user_hash' => user_data,
+            },
+          }
+        )
       end
 
       def user_data
@@ -40,12 +50,12 @@ module OmniAuth
           :method => 'taobao.user.get',
           :session => @access_token.token,
           :sign_method => 'md5',
-          :timestamp   => Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+          :timestamp   => Time.now.strftime('%Y-%m-%d %H:%M:%S'),
           :v => '2.0'
         }
         query_param = generate_sign(query_param)
         res = Net::HTTP.post_form(URI.parse(url), query_param)
-        @data ||= MultiJson.decode(res.body)["user_get_response"]["user"]
+        @data ||= MultiJson.decode(res.body)['user_get_response']['user']
       end
 
       def request_phase
@@ -55,25 +65,17 @@ module OmniAuth
 
       def user_info
         {
-          'name' => user_data["nick"],
-          'email' => (user_data["email"] if user_data["email"]),
+          'name' => user_data['nick'],
+          'email' => (user_data['email'] if user_data['email']),
         }
       end
 
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['uid'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data}
-        })
-      end
-
       def generate_sign(params)
-        str = client_secret + (params.sort.collect { |k, v| "#{k}#{v}" }).join + client_secret
-        params["sign"] = Digest::MD5.hexdigest(str).upcase!
+        # params.sort.collect { |k, v| "#{k}#{v}" }
+        str = client_secret + params.sort {|a,b| "#{a[0]}"<=>"#{b[0]}"}.flatten.join + client_secret
+        params['sign'] = Digest::MD5.hexdigest(str).upcase!
         params
       end
-
     end
   end
 end

data/lib/omniauth/strategies/{teambox.rb → oauth2/teambox.rb}

@@ -3,17 +3,29 @@ require 'multi_json'
 
 module OmniAuth
   module Strategies
-    class Teambox < OAuth2
-      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
+    class Teambox < OmniAuth::Strategies::OAuth2
+      def initialize(app, client_id=nil, client_secret=nil, options={}, &block)
         client_options = {
-          :site => "https://teambox.com/",
-          :authorize_path => "/oauth/authorize",
-          :access_token_path => "/oauth/token"
+          :authorize_url => 'https://teambox.com/oauth/authorize',
+          :token_url => 'https://teambox.com/oauth/token',
         }
         super(app, :teambox, client_id, client_secret, client_options, options, &block)
       end
+
+      def auth_hash
+        OmniAuth::Utils.deep_merge(
+          super, {
+            'uid' => user_data['id'],
+            'user_info' => user_info,
+            'extra' => {
+              'user_hash' => user_data
+            },
+          }
+        )
+      end
+
       def request_phase
-        options[:scope] ||= "offline_access"
+        options[:scope] ||= 'offline_access'
         options[:response_type] ||= 'code'
         super
       end
@@ -24,7 +36,7 @@ module OmniAuth
       end
 
       def user_data
-        @data ||= MultiJson.decode(@access_token.get("/api/1/account"))
+        @data ||= MultiJson.decode(@access_token.get('/api/1/account'))
       end
 
       def user_info
@@ -32,18 +44,8 @@ module OmniAuth
           'nickname' => user_data['username'],
           'name' => user_data['first_name'],
           'image' => user_data['avatar_url'],
-          'urls' => {}
         }
       end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['id'],
-          'user_info' => user_info,
-          'extra' => {'user_hash' => user_data}
-        })
-      end
     end
   end
 end
-

data/lib/omniauth/strategies/{thirty_seven_signals.rb → oauth2/thirty_seven_signals.rb}

@@ -3,17 +3,27 @@ require 'multi_json'
 
 module OmniAuth
   module Strategies
-    class ThirtySevenSignals < OAuth2
-      def initialize(app, client_id = nil, client_secret = nil, options = {}, &block)
+    class ThirtySevenSignals < OmniAuth::Strategies::OAuth2
+      def initialize(app, client_id=nil, client_secret=nil, options={}, &block)
         client_options = {
-          :site => 'https://launchpad.37signals.com/',
-          :authorize_path => '/authorization/new',
-          :access_token_path => '/authorization/token'
+          :authorize_url => 'https://launchpad.37signals.com/authorization/new',
+          :token_url => 'https://launchpad.37signals.com/authorization/token',
         }
-
         super(app, :thirty_seven_signals, client_id, client_secret, client_options, options, &block)
       end
 
+      def auth_hash
+        OmniAuth::Utils.deep_merge(
+          super, {
+            'uid' => user_data['identity']['id'],
+            'user_info' => user_info,
+            'extra' => {
+              'accounts' => user_data['accounts'],
+            }
+          }
+        )
+      end
+
       def user_data
         @data ||= MultiJson.decode(@access_token.get('/authorization.json'))
       end
@@ -23,19 +33,9 @@ module OmniAuth
           'email' => user_data['identity']['email_address'],
           'first_name' => user_data['identity']['first_name'],
           'last_name' => user_data['identity']['last_name'],
-          'name' => [user_data['identity']['first_name'], user_data['identity']['last_name']].join(' ').strip
+          'name' => [user_data['identity']['first_name'], user_data['identity']['last_name']].join(' ').strip,
         }
       end
-
-      def auth_hash
-        OmniAuth::Utils.deep_merge(super, {
-          'uid' => user_data['identity']['id'],
-          'user_info' => user_info,
-          'extra' => {
-            'accounts' => user_data['accounts']
-          }
-        })
-      end
     end
   end
 end

data/lib/omniauth/strategies/oauth2/viadeo.rb

@@ -0,0 +1,72 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    # Authenticate to Viadeo utilizing OAuth 2.0 and retrieve
+    # basic user information.
+    #
+    # @example Basic Usage
+    #   use OmniAuth::Strategies::Viadeo, 'client_id', 'client_secret'
+    class Viadeo < OmniAuth::Strategies::OAuth2
+      # @param [Rack Application] app standard middleware application parameter
+      # @param [String] client_id the application id as [registered on Viadeo](http://dev.viadeo.com/)
+      # @param [String] client_secret the application secret as registered on Facebook
+      def initialize(app, client_id=nil, client_secret=nil, options = {}, &block)
+        client_options = {
+          :site => 'https://api.viadeo.com/',
+          :authorize_url => 'https://secure.viadeo.com/oauth-provider/authorize2',
+          :token_url => 'https://secure.viadeo.com/oauth-provider/access_token2'
+        }
+        super(app, :viadeo, client_id, client_secret, client_options, options, &block)
+      end
+      
+      def auth_hash
+        OmniAuth::Utils.deep_merge(
+          super, {
+            'uid' => user_data['id'],
+            'user_info' => user_info,
+            'extra' => {
+              'user_hash' => user_data,
+            },
+          }
+        )
+      end
+
+      def user_data
+        @data ||= MultiJson.decode(@access_token.get('/me').body)
+      end
+
+      def request_phase
+        options[:response_type] ||= 'code'
+        super
+      end
+
+      def callback_phase
+        options[:grant_type] ||= 'authorization_code'
+        super
+      end
+
+      def user_info
+        {
+          'name' => user_data['name'],
+          'link' => user_data['link'],
+          'first_name' => user_data['first_name'],
+          'last_name' => user_data['last_name'],
+          'gender' => user_data['gender'],
+          'nickname' => user_data['nickname'],
+          'has_picture' => user_data['has_picture'] ,         
+          'picture_small' => user_data['picture_small'],
+          'picture_large' => user_data['picture_large'],
+          'headline' => user_data['headline'],
+          'introduction' => user_data['introduction'],
+          'interests' => user_data['interests'],
+          'location' => user_data['location'],
+          'is_premium' => user_data['is_premium'],
+          'premium_since' => user_data['premium_since']         
+        }
+      end
+      
+    end
+  end
+end

data/lib/omniauth/strategies/oauth2/vkontakte.rb

@@ -0,0 +1,104 @@
+require 'omniauth/oauth'
+require 'multi_json'
+
+module OmniAuth
+  module Strategies
+    # Authenticate to Vkontakte utilizing OAuth 2.0 and retrieve
+    # basic user information.
+    # documentation available here:
+    # http://vkontakte.ru/developers.php?o=-17680044&p=Authorization&s=0
+    #
+    # @example Basic Usage
+    #     use OmniAuth::Strategies::Vkontakte, 'API Key', 'Secret Key'
+    class Vkontakte < OmniAuth::Strategies::OAuth2
+      # @param [Rack Application] app standard middleware application parameter
+      # @param [String] client_id the application id as [registered in Vkontakte]
+      # @param [String] client_secret the application secret as [registered in Vkontakte]
+      def initialize(app, client_id=nil, client_secret=nil, options={}, &block)
+        client_options = {
+          :authorize_url => 'http://api.vkontakte.ru/oauth/authorize',
+          :token_url => 'https://api.vkontakte.ru/oauth/token',
+        }
+        super(app, :vkontakte, client_id, client_secret, client_options, options, &block)
+      end
+
+      def auth_hash
+        # process user's info
+        user_data
+        OmniAuth::Utils.deep_merge(
+          super, {
+            'uid' => @data['uid'],
+            'user_info' => user_info,
+            'extra' => user_hash,
+          }
+        )
+      end
+
+      def user_data
+        # http://vkontakte.ru/developers.php?o=-17680044&p=Description+of+Fields+of+the+fields+Parameter
+        @fields ||= ['uid', 'first_name', 'last_name', 'nickname', 'domain', 'sex', 'bdate', 'city', 'country', 'timezone', 'photo', 'photo_big']
+
+        # http://vkontakte.ru/developers.php?o=-1&p=getProfiles
+        response = @access_token.get('https://api.vkontakte.ru/method/getProfiles',
+          :params => {:uid => @access_token['user_id'], :fields => @fields.join(',')}, :parse => :json)
+        @data ||= response.parsed['response'][0]
+
+        # we need these 2 additional requests since vkontakte returns only ids of the City and Country
+        # http://vkontakte.ru/developers.php?o=-17680044&p=getCities
+        response = @access_token.get('https://api.vkontakte.ru/method/getCities',
+          :params => {:cids => @data['city']}, :parse => :json)
+        cities = response.parsed['response']
+        @city ||= cities.first['name'] if cities && cities.first
+
+        # http://vkontakte.ru/developers.php?o=-17680044&p=getCountries
+        response = @access_token.get('https://api.vkontakte.ru/method/getCountries',
+          :params => {:cids => @data['country']}, :parse => :json)
+        countries = response.parsed['response']
+        @country ||= countries.first['name'] if countries && countries.first
+      end
+
+      def request_phase
+        options[:response_type] ||= 'code'
+        super
+      end
+
+      def build_access_token
+        token = super
+        # indicates that `offline` permission was granted, no need to the token refresh
+        if token.expires_in == 0
+          ::OAuth2::AccessToken.new(token.client, token.token,
+            token.params.reject{|k,_| [:refresh_token, :expires_in, :expires_at, :expires].include? k.to_sym}
+          )
+        else
+          token
+        end
+      end
+
+      def user_info
+        {
+          'first_name' => @data['first_name'],
+          'last_name' => @data['last_name'],
+          'name' => "#{@data['first_name']} #{@data['last_name']}".strip,
+          'nickname' => @data['nickname'],
+          'birth_date' => @data['bdate'],
+          'image' => @data['photo'],
+          'location' => "#{@country}, #{@city}",
+          'urls' => {
+            'Vkontakte' => "http://vkontakte.ru/#{@data['domain']}",
+          },
+        }
+      end
+
+      def user_hash
+        {
+          'user_hash' => {
+            'gender' => @data['sex'],
+            'timezone' => @data['timezone'],
+            # 200px maximum resolution of the avatar (http://vkontakte.ru/developers.php?o=-17680044&p=Description+of+Fields+of+the+fields+Parameter)
+            'photo_big' => @data['photo_big'],
+          }
+        }
+      end
+    end
+  end
+end