panjiva-oauth-plugin 0.4.1

data/lib/oauth/models/consumers/service_loader.rb

@@ -0,0 +1,28 @@
+require 'oauth/controllers/consumer_controller'
+
+# Goes through the entries in your OAUTH_CREDENTIALS and either loads the class required
+# or subclasses ConsumerToken with the name.
+#
+# So an entry called "my_service" will create a class MyServiceToken which you can
+# connect with has_one to your user model.
+if defined? ConsumerToken && defined? OAUTH_CREDENTIALS
+  require File.join(File.dirname(__FILE__), 'services', 'oauth2_token')
+
+  OAUTH_CREDENTIALS.each do |key, value|
+    class_name=value[:class_name]||"#{key.to_s.classify}Token"
+    unless Object.const_defined?(class_name.to_sym)
+      if File.exists?(File.join(File.dirname(__FILE__), "services","#{key.to_s}_token.rb"))
+        Rails.logger.info File.join(File.dirname(__FILE__), "services","#{key.to_s}_token")
+        require File.join(File.dirname(__FILE__), "services","#{key.to_s}_token")
+      else
+        begin
+          # Let Rails auto-load from the models folder
+          eval class_name
+        rescue NameError
+          super_class = value[:super_class]||value[:oauth_version].to_i>=2 ? "Oauth2Token" : "ConsumerToken"
+          eval "class #{class_name} < #{super_class} ;end"
+        end
+      end
+    end
+  end
+end

data/lib/oauth/models/consumers/services/agree2_token.rb

@@ -0,0 +1,15 @@
+require 'agree2'
+class Agree2Token < ConsumerToken
+  AGREE2_SETTINGS={:site=>"https://agree2.com"}
+  def self.consumer
+    @consumer||=OAuth::Consumer.new credentials[:key],credentials[:secret],AGREE2_SETTINGS
+  end
+
+  def self.agree2_client
+    @agree2_client||=Agree2::Client.new credentials[:key],credentials[:secret]
+  end
+
+  def client
+    @client||=Agree2Token.agree2_client.user(token,secret)
+  end
+end

data/lib/oauth/models/consumers/services/fireeagle_token.rb

@@ -0,0 +1,39 @@
+require 'fireeagle'
+# For more information on FireEagle
+# http://fireeagle.rubyforge.org/
+class FireeagleToken < ConsumerToken
+  FIREEAGLE_SETTINGS={
+    :site=>"https://fireeagle.yahooapis.com",
+    :authorize_url=>"https://fireeagle.yahoo.net/oauth/authorize"}
+
+  def self.consumer
+    @consumer||=OAuth::Consumer.new credentials[:key],credentials[:secret],FIREEAGLE_SETTINGS
+  end
+
+  def client
+    @client||=FireEagle::Client.new :consumer_key => FireeagleToken.consumer.key,
+                                    :consumer_secret => FireeagleToken.consumer.secret,
+                                    :access_token => token,
+                                    :access_token_secret => secret
+  end
+
+  # Returns the FireEagle User object
+  # http://fireeagle.rubyforge.org/classes/FireEagle/User.html
+  def fireeagle_user
+    @fireeagle_user||=client.user
+  end
+
+  # gives you the best guess of a location for user.
+  # This returns the FireEagle Location object:
+  # http://fireeagle.rubyforge.org/classes/FireEagle/Location.html
+  def location
+    fireeagle_user.best_guess.name
+  end
+
+  # Updates thes users location
+  # see: http://fireeagle.rubyforge.org/classes/FireEagle/Client.html#M000026
+  def update_location(location={})
+    client.update(location)
+  end
+end
+

data/lib/oauth/models/consumers/services/google_token.rb

@@ -0,0 +1,21 @@
+class GoogleToken < ConsumerToken
+  GOOGLE_SETTINGS={
+    :site=>"https://www.google.com",
+    :request_token_path => "/accounts/OAuthGetRequestToken",
+    :authorize_path => "/accounts/OAuthAuthorizeToken",
+    :access_token_path => "/accounts/OAuthGetAccessToken",
+  }
+
+  def self.consumer
+    @consumer||=create_consumer
+  end
+
+  def self.create_consumer(options={})
+    OAuth::Consumer.new credentials[:key],credentials[:secret],GOOGLE_SETTINGS.merge(options)
+  end
+
+  def self.get_request_token(callback_url, scope=nil)
+    consumer.get_request_token({:oauth_callback=>callback_url}, :scope=>scope||credentials[:scope]||"http://www-opensocial.googleusercontent.com/api/people")
+  end
+
+end

data/lib/oauth/models/consumers/services/oauth2_token.rb

@@ -0,0 +1,27 @@
+require 'oauth2'
+class Oauth2Token < ConsumerToken
+
+  def self.consumer
+    @consumer||=create_consumer
+  end
+
+  def self.create_consumer(options={})
+    @consumer||=OAuth2::Client.new credentials[:key],credentials[:secret],credentials[:options]
+  end
+
+  def self.authorize_url(callback_url)
+    options = {:redirect_uri=>callback_url}
+    options[:scope] = credentials[:scope] if credentials[:scope].present?
+    consumer.auth_code.authorize_url(options)
+  end
+
+  def self.access_token(user, code, redirect_uri)
+    access_token = consumer.auth_code.get_token(code, :redirect_uri => redirect_uri)
+    find_or_create_from_access_token user, access_token
+  end
+
+  def client
+    @client ||= OAuth2::AccessToken.new self.class.consumer, token
+  end
+
+end

data/lib/oauth/models/consumers/services/opentransact_token.rb

@@ -0,0 +1,15 @@
+require 'opentransact'
+class OpenTransactToken < ConsumerToken
+
+#  def self.server
+#    @consumer||=OpenTransact::Server.new credentials
+#  end
+
+#  def self.consumer
+#    @consumer||=server.consumer
+#  end
+
+  def client
+    @client ||= OpenTransact::Client.new self.class.credentials.merge( {:token=>token, :secret=>secret})
+  end
+end

data/lib/oauth/models/consumers/services/picomoney_token.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__),'opentransact_token')
+
+class PicomoneyToken < OpenTransactToken
+
+  def self.credentials
+    @credentials||={
+        :site=>"https://picomoney.com",
+        :consumer_key => super[:key],
+        :consumer_secret => super[:secret]
+      }.merge(super)
+  end
+
+  def about_user
+    client.get("/about_user")
+  end
+
+end

data/lib/oauth/models/consumers/services/twitter_token.rb

@@ -0,0 +1,24 @@
+class TwitterToken < ConsumerToken
+  TWITTER_SETTINGS={
+    :site => "https://api.twitter.com",
+    :request_token_path => "/oauth/request_token",
+    :authorize_path => "/oauth/authorize",
+    :access_token_path => "/oauth/access_token",
+  }
+
+  def self.consumer(options={})
+    @consumer ||= OAuth::Consumer.new(credentials[:key], credentials[:secret], TWITTER_SETTINGS.merge(options))
+  end
+
+  def client
+    @client ||= begin 
+      if self.class.credentials[:client].to_sym == :oauth_gem
+        super
+      else
+        require 'twitter'
+        Twitter::Client.new(:consumer_key => self.class.consumer.key, :consumer_secret => self.class.consumer.secret)
+      end
+    end
+  end
+
+end

data/lib/oauth/models/consumers/simple_client.rb

@@ -0,0 +1,50 @@
+require 'json'
+module Oauth
+  module Models
+    module Consumers
+      # This is just a simple
+      class SimpleClient
+        attr_reader :token
+
+        def initialize(token)
+          @token = token
+        end
+
+
+        def put(path,params={})
+          parse(token.put(path,params, {'Accept' => 'application/json'}))
+        end
+
+        def delete(path)
+          parse(token.delete(path, {'Accept' => 'application/json'}))
+        end
+
+        def post(path,params={})
+          parse(token.post(path,params, {'Accept' => 'application/json'}))
+        end
+
+        def get(path)
+          parse(token.get(path, {'Accept' => 'application/json'}))
+        end
+
+        protected
+
+        def parse(response)
+          return false unless response
+          if ["200","201"].include? response.code
+            unless response.body.blank?
+              JSON.parse(response.body)
+            else
+              true
+            end
+          else
+            logger.debug "Got Response code: #{response.code}"
+            false
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/oauth/models/consumers/token.rb

@@ -0,0 +1,93 @@
+require 'oauth/consumer'
+require File.join(File.dirname(__FILE__), 'simple_client')
+
+module Oauth
+  module Models
+    module Consumers
+      module Token
+        def self.included(model)
+          model.class_eval do
+            validates_presence_of :user, :token
+          end
+
+          model.send(:include, InstanceMethods)
+          model.send(:extend, ClassMethods)
+
+        end
+
+        module ClassMethods
+
+          def service_name
+            @service_name||=self.to_s.underscore.scan(/^(.*?)(_token)?$/)[0][0].to_sym
+          end
+
+          def consumer
+            options = credentials[:options] || {}
+            @consumer||=OAuth::Consumer.new credentials[:key],credentials[:secret],options
+          end
+
+          def get_request_token(callback_url)
+            consumer.get_request_token(:oauth_callback=>callback_url)
+          end
+
+          def find_or_create_from_request_token(user,token,secret,oauth_verifier)
+            request_token=OAuth::RequestToken.new consumer,token,secret
+            options={}
+            options[:oauth_verifier]=oauth_verifier if oauth_verifier
+            access_token=request_token.get_access_token options
+            find_or_create_from_access_token user, access_token
+          end
+
+          def find_or_create_from_access_token(user,access_token)
+            secret = access_token.respond_to?(:secret) ? access_token.secret : nil
+            if user
+              token = self.find_or_initialize_by_user_id_and_token(user.id, access_token.token)
+            else
+              token = self.find_or_initialize_by_token(access_token.token)
+            end
+
+            # set or update the secret
+            token.secret = secret
+            token.save! if token.new_record? or token.changed?
+
+            token
+          end
+
+          def build_user_from_token
+          end
+          
+          def credentials
+            @credentials||=OAUTH_CREDENTIALS[service_name]
+          end
+
+        end
+
+        module InstanceMethods
+
+          # Main client for interfacing with remote service. Override this to use
+          # preexisting library eg. Twitter gem.
+          def client
+            @client||=OAuth::AccessToken.new self.class.consumer,token,secret
+          end
+
+          def simple_client
+            @simple_client||=SimpleClient.new client
+          end
+
+          # Override this to return user data from service
+          def params_for_user
+            {}
+          end
+
+          def create_user
+            self.user ||= begin
+              User.new params_for_user
+              user.save(:validate=>false)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/oauth/provider/authorizer.rb

@@ -0,0 +1,83 @@
+require 'uri'
+
+module OAuth
+  module Provider
+    class Authorizer
+      attr_accessor :user, :params, :app
+
+      def initialize(user, authorized, params = {})
+        @user = user
+        @params = params
+        @authorized = authorized
+      end
+
+      def app
+        @app ||= ::ClientApplication.find_by_key!(params[:client_id])
+      end
+
+      def code
+        @code ||= ::Oauth2Verifier.create! :client_application => app,
+                                      :user => @user,
+                                      :scope => @params[:scope],
+                                      :callback_url => @params[:redirect_uri]
+      end
+
+      def token
+        @token ||= ::Oauth2Token.create! :client_application => app,
+                                      :user => @user,
+                                      :scope => @params[:scope],
+                                      :callback_url => @params[:redirect_uri]
+      end
+
+      def authorized?
+        @authorized == true
+      end
+
+      def redirect_uri
+        uri = base_uri
+        if params[:response_type] == 'code'
+          if uri.query
+            uri.query << '&'
+          else
+            uri.query = ''
+          end
+          uri.query << encode_response
+        else
+          uri.fragment = encode_response
+        end
+        uri.to_s
+      end
+
+      def response
+        r = {}
+        if ['token','code'].include? params[:response_type]
+          if authorized?
+            if params[:response_type] == 'code'
+              r[:code] = code.token
+            else
+              r[:access_token] = token.token
+            end
+          else
+            r[:error] = 'access_denied'
+          end
+        else
+          r[:error] = 'unsupported_response_type'
+        end
+        r[:state] = params[:state] if params[:state]
+        r
+      end
+
+      def encode_response
+        response.map do |k, v|
+          [URI.escape(k.to_s),URI.escape(v)] * "="
+        end * "&"
+      end
+
+      protected
+
+        def base_uri
+          URI.parse(params[:redirect_uri] || app.callback_url)
+        end
+    end
+  end
+end

data/lib/oauth/rack/oauth_filter.rb

@@ -0,0 +1,93 @@
+require "rack"
+require "rack/request"
+require "oauth"
+require "oauth/request_proxy/rack_request"
+
+module OAuth
+  module Rack
+
+    # An OAuth 1.0a filter to be used together with the oauth-plugin for rails.T
+    # This is still experimental
+    #
+    # Add it as middleware to your config/application.rb:
+    #
+    # require 'oauth/rack/oauth_filter'
+    # config.middleware.use OAuth::Rack::OAuthFilter
+
+    class OAuthFilter
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ::Rack::Request.new(env)
+        env["oauth_plugin"] = true
+        strategies = []
+        if token_string = oauth2_token(request)
+          if token = Oauth2Token.first(:conditions => ['invalidated_at IS NULL AND authorized_at IS NOT NULL and token = ?', token_string])
+            env["oauth.token"]   = token
+            env["oauth.version"] = 2
+            strategies << :oauth20_token
+            strategies << :token
+          end
+
+        elsif oauth1_verify(request) do |request_proxy|
+            client_application = ClientApplication.find_by_key(request_proxy.consumer_key)
+            env["oauth.client_application_candidate"] = client_application
+
+            # Store this temporarily in client_application object for use in request token generation
+            client_application.token_callback_url = request_proxy.oauth_callback if request_proxy.oauth_callback
+            oauth_token = nil
+
+            if request_proxy.token
+              oauth_token = client_application.tokens.first(:conditions => ['invalidated_at IS NULL AND authorized_at IS NOT NULL and token = ?', request_proxy.token])
+              if oauth_token.respond_to?(:provided_oauth_verifier=)
+                oauth_token.provided_oauth_verifier = request_proxy.oauth_verifier
+              end
+              env["oauth.token_candidate"] = oauth_token
+            end
+            # return the token secret and the consumer secret
+            [(oauth_token.nil? ? nil : oauth_token.secret), (client_application.nil? ? nil : client_application.secret)]
+        end
+          if env["oauth.token_candidate"]
+            env["oauth.token"] = env["oauth.token_candidate"]
+            strategies << :oauth10_token
+            if env["oauth.token"].is_a?(::RequestToken)
+              strategies << :oauth10_request_token
+            elsif env["oauth.token"].is_a?(::AccessToken)
+              strategies << :token
+              strategies << :oauth10_access_token
+            end
+          else
+            strategies << :two_legged
+          end
+          env["oauth.client_application"] = env["oauth.client_application_candidate"]
+          env["oauth.version"] = 1
+
+        end
+        env["oauth.strategies"] = strategies unless strategies.empty?
+        env["oauth.client_application_candidate"] = nil
+        env["oauth.token_candidate"] = nil
+        @app.call(env)
+      end
+
+      def oauth1_verify(request, options = {}, &block)
+        begin
+          signature = OAuth::Signature.build(request, options, &block)
+          return false unless OauthNonce.remember(signature.request.nonce, signature.request.timestamp)
+          value = signature.verify
+          value
+        rescue OAuth::Signature::UnknownSignatureMethod => e
+          false
+        end
+      end
+
+      def oauth2_token(request)
+        request.params['bearer_token'] || request.params['access_token'] || (request.params["oauth_token"] && !request.params["oauth_signature"] ? request.params["oauth_token"] : nil )  ||
+          request.env["HTTP_AUTHORIZATION"] &&
+          !request.env["HTTP_AUTHORIZATION"][/(oauth_version="1.0")/] &&
+          request.env["HTTP_AUTHORIZATION"][/^(Bearer|OAuth|Token) (token=)?([^\s]*)$/, 3]
+      end
+    end
+  end
+end