le1t0-oauth-plugin 0.3.14.001

data/generators/oauth_provider/templates/oauth_token_test.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class RequestTokenTest < ActiveSupport::TestCase
+
+  fixtures :client_applications, :users, :oauth_tokens
+  
+  def setup
+    @token = RequestToken.create :client_application=>client_applications(:one)
+  end
+
+  def test_should_be_valid
+    assert @token.valid?
+  end
+  
+  def test_should_not_have_errors
+    assert @token.errors.empty?
+  end
+  
+  def test_should_have_a_token
+    assert_not_nil @token.token
+  end
+
+  def test_should_have_a_secret
+    assert_not_nil @token.secret
+  end
+  
+  def test_should_not_be_authorized 
+    assert !@token.authorized?
+  end
+
+  def test_should_not_be_invalidated
+    assert !@token.invalidated?
+  end
+  
+  def test_should_authorize_request
+    @token.authorize!(users(:quentin))
+    assert @token.authorized?
+    assert_not_nil @token.authorized_at
+    assert_equal users(:quentin), @token.user
+  end
+  
+  def test_should_not_exchange_without_approval
+    assert_equal false, @token.exchange!
+    assert_equal false, @token.invalidated?
+  end
+  
+  def test_should_not_exchange_without_approval
+    @token.authorize!(users(:quentin))
+    @access = @token.exchange!
+    assert_not_equal false, @access
+    assert @token.invalidated?
+    
+    assert_equal users(:quentin), @access.user
+    assert @access.authorized?
+  end
+  
+end

data/generators/oauth_provider/templates/oauth_tokens.yml

@@ -0,0 +1,17 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+one:
+  id: 1
+  user_id: 1
+  client_application_id: 1
+  token: one
+  secret: MyString
+  created_at: 2007-11-19 07:31:46
+  updated_at: 2007-11-19 07:31:46
+two:
+  id: 2
+  user_id: 1
+  client_application_id: 1
+  token: two
+  secret: MyString
+  created_at: 2007-11-19 07:31:46
+  updated_at: 2007-11-19 07:31:46

data/generators/oauth_provider/templates/request_token.rb

@@ -0,0 +1,40 @@
+class RequestToken < OauthToken
+  
+  attr_accessor :provided_oauth_verifier
+  
+  def authorize!(user)
+    return false if authorized?
+    self.user = user
+    self.authorized_at = Time.now
+    self.verifier=OAuth::Helper.generate_key(16)[0,20] unless oauth10?
+    self.save
+  end
+  
+  def exchange!
+    return false unless authorized?
+    return false unless oauth10? || verifier==provided_oauth_verifier
+    
+    RequestToken.transaction do
+      access_token = AccessToken.create(:user => user, :client_application => client_application)
+      invalidate!
+      access_token
+    end
+  end
+  
+  def to_query
+    if oauth10?
+      super
+    else
+      "#{super}&oauth_callback_confirmed=true"
+    end
+  end
+  
+  def oob?
+    self.callback_url=='oob'
+  end
+  
+  def oauth10?
+    (defined? OAUTH_10_SUPPORT) && OAUTH_10_SUPPORT && self.callback_url.blank?
+  end
+
+end

data/generators/oauth_provider/templates/show.html.erb

@@ -0,0 +1,27 @@
+<h1>OAuth details for <%%=@client_application.name %></h1>
+<p>
+  <strong>Consumer Key:</strong>
+  <code><%%=@client_application.key %></code>
+</p>
+<p>
+  <strong>Consumer Secret:</strong>
+  <code><%%=@client_application.secret %></code>
+</p>
+<p>
+  <strong>Request Token URL</strong>
+  <code>http<%%='s' if request.ssl? %>://<%%= request.host_with_port %><%%=@client_application.oauth_server.request_token_path %></code>
+</p>
+<p>
+  <strong>Access Token URL</strong>
+  <code>http<%%='s' if request.ssl? %>://<%%= request.host_with_port %><%%=@client_application.oauth_server.access_token_path %></code>
+</p>
+<p>
+  <strong>Authorize URL</strong>
+  <code>http<%%='s' if request.ssl? %>://<%%= request.host_with_port %><%%=@client_application.oauth_server.authorize_path %></code>
+</p>
+
+<p>
+  We support hmac-sha1 (recommended) as well as plain text in ssl mode.
+</p>
+<%%= link_to 'Edit', edit_oauth_client_path(@client_application) %> |
+<%%= link_to 'Back', oauth_clients_path %>

data/generators/oauth_provider/templates/show.html.haml

@@ -0,0 +1,30 @@
+%h1 
+  OAuth details for 
+  =@client_application.name
+%p
+  %strong Consumer Key:
+  %code=@client_application.key
+%p
+  %strong Consumer Secret:
+  %code=@client_application.secret 
+
+%p
+  %strong Request Token URL
+  %code
+    ="http#{'s' if request.ssl?}://#{request.host_with_port}#{@client_application.oauth_server.request_token_path}"
+
+%p
+  %strong Access Token URL
+  %code
+    ="http#{'s' if request.ssl?}://#{request.host_with_port}#{@client_application.oauth_server.access_token_path}"
+
+%p
+  %strong Authorize URL
+  %code
+    ="http#{'s' if request.ssl?}://#{request.host_with_port}#{@client_application.oauth_server.authorize_path}"
+
+%p
+  We support hmac-sha1 (recommended) as well as plain text in ssl mode.
+
+= link_to 'Edit', edit_oauth_client_path(@client_application)
+= link_to 'Back', oauth_clients_path

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"  

data/install.rb

@@ -0,0 +1,2 @@
+#should we do any text formatting?
+puts IO.read(File.join(File.dirname(__FILE__), 'README.rdoc'))

data/lib/oauth-plugin.rb

@@ -0,0 +1 @@
+# leaving this empty 

data/lib/oauth/controllers/application_controller_methods.rb

@@ -0,0 +1,110 @@
+require 'oauth/signature'
+module OAuth
+  module Controllers
+   
+    module ApplicationControllerMethods
+      protected
+      
+      def current_token
+        @current_token
+      end
+      
+      def current_client_application
+        @current_client_application
+      end
+      
+      def oauthenticate
+        verified=verify_oauth_signature 
+        return verified && current_token.is_a?(::AccessToken)
+      end
+      
+      def oauth?
+        current_token!=nil
+      end
+      
+      # use in a before_filter
+      def oauth_required
+        if oauthenticate
+          if authorized?
+            return true
+          else
+            invalid_oauth_response
+          end
+        else          
+          invalid_oauth_response
+        end
+      end
+      
+      # This requies that you have an acts_as_authenticated compatible authentication plugin installed
+      def login_or_oauth_required
+        if oauthenticate
+          if authorized?
+            return true
+          else
+            invalid_oauth_response
+          end
+        else
+          login_required
+        end
+      end
+      
+      
+      # verifies a request token request
+      def verify_oauth_consumer_signature
+        begin
+          valid = ClientApplication.verify_request(request) do |request_proxy|
+            @current_client_application = ClientApplication.find_by_key(request_proxy.consumer_key)
+            
+            # Store this temporarily in client_application object for use in request token generation 
+            @current_client_application.token_callback_url=request_proxy.oauth_callback if request_proxy.oauth_callback
+            
+            # return the token secret and the consumer secret
+            [nil, @current_client_application.secret]
+          end
+        rescue
+          valid=false
+        end
+
+        invalid_oauth_response unless valid
+      end
+
+      def verify_oauth_request_token
+        verify_oauth_signature && current_token.is_a?(::RequestToken)
+      end
+
+      def invalid_oauth_response(code=401,message="Invalid OAuth Request")
+        render :text => message, :status => code
+      end
+
+      private
+      
+      def current_token=(token)
+        @current_token=token
+        if @current_token
+          @current_user=@current_token.user
+          @current_client_application=@current_token.client_application 
+        end
+        @current_token
+      end
+      
+      # Implement this for your own application using app-specific models
+      def verify_oauth_signature
+        begin
+          valid = ClientApplication.verify_request(request) do |request_proxy|
+            self.current_token = ClientApplication.find_token(request_proxy.token)
+            if self.current_token.respond_to?(:provided_oauth_verifier=)
+              self.current_token.provided_oauth_verifier=request_proxy.oauth_verifier 
+            end
+            # return the token secret and the consumer secret
+            [(current_token.nil? ? nil : current_token.secret), (current_client_application.nil? ? nil : current_client_application.secret)]
+          end
+          # reset @current_user to clear state for restful_...._authentication
+          @current_user = nil if (!valid)
+          valid
+        rescue
+          false
+        end
+      end
+    end
+  end
+end

data/lib/oauth/controllers/consumer_controller.rb

@@ -0,0 +1,76 @@
+module Oauth
+  module Controllers
+    module ConsumerController
+      def self.included(controller)
+        controller.class_eval do  
+          before_filter :login_required
+          before_filter :load_consumer, :except=>:index
+          skip_before_filter :verify_authenticity_token,:only=>:callback
+        end
+      end
+      
+      def index
+        @consumer_tokens=ConsumerToken.all :conditions=>{:user_id=>current_user.id}
+        # The services the user hasn't already connected to
+        @services=OAUTH_CREDENTIALS.keys-@consumer_tokens.collect{|c| c.class.service_name}
+      end
+      
+      
+      # creates request token and redirects on to oauth provider's auth page
+      # If user is already connected it displays a page with an option to disconnect and redo
+      def show
+        unless @token
+          @request_token=@consumer.get_request_token(callback_oauth_consumer_url(params[:id]))
+          session[@request_token.token]=@request_token.secret
+          if @request_token.callback_confirmed?
+            redirect_to @request_token.authorize_url
+          else
+            redirect_to(@request_token.authorize_url + "&oauth_callback=#{callback_oauth_consumer_url(params[:id])}")
+          end
+        end
+      end
+
+      def callback
+        @request_token_secret=session[params[:oauth_token]]
+        if @request_token_secret
+          @token=@consumer.create_from_request_token(current_user,params[:oauth_token],@request_token_secret,params[:oauth_verifier])
+          if @token
+            flash[:notice] = "#{params[:id].humanize} was successfully connected to your account"
+            go_back
+          else
+            flash[:error] = "An error happened, please try connecting again"
+            redirect_to oauth_consumer_url(params[:id])
+          end
+        end
+
+      end
+
+      def destroy
+        throw RecordNotFound unless @token
+        @token.destroy
+        if params[:commit]=="Reconnect"
+          redirect_to oauth_consumer_url(params[:id])
+        else
+          flash[:notice] = "#{params[:id].humanize} was successfully disconnected from your account"
+          
+          go_back
+        end
+      end
+
+      protected
+      
+      # Override this in your controller to decide where you want to redirect user to after callback is finished.
+      def go_back
+        redirect_to root_url
+      end
+      
+      def load_consumer
+        consumer_key=params[:id].to_sym
+        throw RecordNotFound unless OAUTH_CREDENTIALS.include?(consumer_key)
+        @consumer="#{consumer_key.to_s.camelcase}Token".constantize
+        @token=@consumer.find_by_user_id current_user.id
+      end
+      
+    end
+  end
+end

data/lib/oauth/controllers/provider_controller.rb

@@ -0,0 +1,117 @@
+module OAuth
+  module Controllers
+   
+    module ProviderController
+      def self.included(controller)
+        controller.class_eval do
+          before_filter :login_required, :only => [:authorize,:revoke]
+          before_filter :login_or_oauth_required, :only => [:test_request]
+          before_filter :oauth_required, :only => [:invalidate,:capabilities]
+          before_filter :verify_oauth_consumer_signature, :only => [:request_token]
+          before_filter :verify_oauth_request_token, :only => [:access_token]
+          skip_before_filter :verify_authenticity_token, :only=>[:request_token, :access_token, :invalidate, :test_request]
+        end
+      end
+      
+      def request_token
+        @token = current_client_application.create_request_token
+        if @token
+          render :text => @token.to_query
+        else
+          render :nothing => true, :status => 401
+        end
+      end 
+
+      def access_token
+        @token = current_token && current_token.exchange!
+        if @token
+          render :text => @token.to_query
+        else
+          render :nothing => true, :status => 401
+        end
+      end
+
+      def test_request
+        render :text => params.collect{|k,v|"#{k}=#{v}"}.join("&")
+      end
+
+      def authorize
+        @token = ::RequestToken.find_by_token params[:oauth_token]
+        unless @token
+          render :action=>"authorize_failure"
+          return
+        end
+        
+        unless @token.invalidated?    
+          if request.post? 
+            if user_authorizes_token?
+              @token.authorize!(current_user)
+              if @token.oauth10?
+                @redirect_url = URI.parse(params[:oauth_callback] || @token.client_application.callback_url)
+              else
+                @redirect_url = URI.parse(@token.oob? ? @token.client_application.callback_url : @token.callback_url)
+              end
+              
+              unless @redirect_url.to_s.blank?
+                if @token.oauth10?
+                  @redirect_url.query = @redirect_url.query.blank? ?
+                                        "oauth_token=#{@token.token}" :
+                                        @redirect_url.query + "&oauth_token=#{@token.token}"
+                  redirect_to @redirect_url.to_s
+                else
+                  @redirect_url.query = @redirect_url.query.blank? ?
+                                        "oauth_token=#{@token.token}&oauth_verifier=#{@token.verifier}" :
+                                        @redirect_url.query + "&oauth_token=#{@token.token}&oauth_verifier=#{@token.verifier}"
+                  redirect_to @redirect_url.to_s
+                end
+              else
+                render :action => "authorize_success"
+              end
+            else
+              @token.invalidate!
+              render :action => "authorize_failure"
+            end
+          end
+        else
+          render :action => "authorize_failure"
+        end
+      end
+
+      def revoke
+        @token = current_user.tokens.find_by_token params[:token]
+        if @token
+          @token.invalidate!
+          flash[:notice] = "You've revoked the token for #{@token.client_application.name}"
+        end
+        redirect_to oauth_clients_url
+      end
+      
+      # Invalidate current token
+      def invalidate
+        current_token.invalidate!
+        head :status=>410
+      end
+      
+      # Capabilities of current_token
+      def capabilities
+        if current_token.respond_to?(:capabilities)
+          @capabilities=current_token.capabilities
+        else
+          @capabilities={:invalidate=>url_for(:action=>:invalidate)}
+        end
+        
+        respond_to do |format|
+          format.json {render :json=>@capabilities}
+          format.xml {render :xml=>@capabilities}
+        end
+      end
+
+      protected
+      
+      # Override this to match your authorization page form
+      def user_authorizes_token?
+        params[:authorize] == '1'
+      end
+    end
+  end
+end