houston-oauth-plugin 0.5.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,49 @@
+require 'oauth2'
+class Oauth2Token < ConsumerToken
+  after_initialize :ensure_access, if: :expired_and_existing?
+
+  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, {refresh_token: refresh_token, expires_at: expires_at, expires_in: expires_in }
+  end
+
+  # @return [Boolean] Is the access token expired and does the record exist in the datastore?
+  def expired_and_existing?
+    return true if !self.new_record? and Time.now.to_i >= self.expires_at.to_i
+    false
+  end
+
+  # Refreshes the access token to ensure access
+  def ensure_access
+    self.class.find_or_create_from_access_token user, self, client.refresh!
+  end
+
+  # Returns the expiration date (expires_in, expires_at)
+  #
+  # @return [String, String] Expires_in and expires_at, respectively
+  # @note It will return the default expiration time as defined in the OAuth 2.0 spec when no options are set
+  def expiration_date(token)
+    return token.expires_in, token.expires_at if !token.expires_in.nil? and !token.expires_at.nil?
+    return token.expires_in, (Time.now.to_i + token.expires_in.to_i) if token.expires_at.nil? and !token.expires_in.nil?
+    return (token.expires_at.to_i - Time.now.to_i), token.expires_at if token.expires_in.nil? and !token.expires_at.nil?
+    return "3600", (Time.now.to_i + 3600)
+  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,121 @@
+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
+
+          # Finds, creates or updates a ConsumerToken by finding the token
+          # or taking it when it's given. It then updates the attributes and saves the changes/new record to a datastore.
+          # @param user [User] The user to which the access token should belong to
+          # @param access_token [AccessToken || Oauth2Token] Either a request token taken from the service or a ConsumerToken
+          # @param new_token [AccessToken] A new access token, used for refreshing the access token with OAuth 2.
+          #
+          # Usage example:
+          # find_or_create_from_access_token(current_user, access_token) <-- Find or create a new access token
+          # find_or_create_from_access-token(current_user, Oauth2Token.last, client.refresh!) <-- Edits existing record with new refreshed information
+          def find_or_create_from_access_token(user, access_token, new_token = nil)
+            if access_token.class.ancestors.include?(Oauth2Token)
+              token = access_token
+            else
+              if user
+                token = self.find_or_initialize_by(user_id: user.id, token: access_token.token)
+              else
+                token = self.find_or_initialize_by(token: access_token.token)
+              end
+            end
+
+            token = if new_token then set_details(new_token, access_token) else set_details(access_token, token) end
+
+            token.save! if token.new_record? or token.changed?
+
+            token
+          end
+
+          # Set the details such as the secret, refresh token and expiration time to an instance of ConsumerToken
+          # @return [ConsumerToken] A ConsumerToken
+          def set_details(access_token, token)
+            secret = access_token.respond_to?(:secret) ? access_token.secret : nil
+            refresh_token = access_token.respond_to?(:refresh_token) ? access_token.refresh_token : nil
+            expires_in, expires_at = token.expiration_date(access_token) if token.class.ancestors.include?(Oauth2Token)
+
+            token.token = access_token.token
+            token.refresh_token = refresh_token
+            token.secret = secret
+            token.expires_at = expires_at
+            token.expires_in = expires_in
+
+            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