dwolla-ruby 1.0.0

data/lib/dwolla/exceptions.rb

@@ -0,0 +1,4 @@
+module Dwolla
+  class RequestException < Exception
+  end
+end

data/lib/dwolla/funding_source.rb

@@ -0,0 +1,18 @@
+module Dwolla
+  class FundingSource
+    attr_accessor :id, :name, :type, :verified
+    def verified?
+      !!verified
+    end
+    
+    def self.from_json(options)
+      source = FundingSource.new
+      source.id = options["Id"]
+      source.name = options["Name"]
+      source.type = options["Type"]
+      source.verified = options["Verified"]
+      source
+    end
+  end
+end
+

data/lib/dwolla/response/follow_redirects.rb

@@ -0,0 +1,44 @@
+module Dwolla
+  module Response
+    class RedirectLimitReached < Faraday::Error::ClientError
+      attr_reader :response
+    
+      def initialize(response)
+        super "too many redirects; last one to: #{response['location']}"
+        @response = response
+      end
+    end
+  
+    class FollowRedirects < Faraday::Middleware
+      REDIRECTS = [301, 302, 303, 307]
+      # default value for max redirects followed
+      FOLLOW_LIMIT = 3
+    
+      def initialize(app, options = {})
+        super(app)
+        @options = options
+        @follow_limit = options[:limit] || FOLLOW_LIMIT
+      end
+    
+      def call(env)
+        process_response(@app.call(env), @follow_limit)
+      end
+    
+      def process_response(response, follows)
+        response.on_complete do |env|
+          if redirect? response
+            raise RedirectLimitReached, response if follows.zero?
+            env[:url] += response['location']
+            env[:method] = :get
+            response = process_response(@app.call(env), follows - 1)
+          end
+        end
+        response
+      end
+    
+      def redirect?(response)
+        REDIRECTS.include? response.status
+      end
+    end
+  end
+end

data/lib/dwolla/response/guard_server_error.rb

@@ -0,0 +1,32 @@
+module Dwolla
+  module Response
+    class InternalServerError < Faraday::Error::ClientError
+      attr_reader :response
+    
+      def initialize(response)
+        super "Internal Server Error"
+        @response = response
+      end
+    end
+    class AccessDeniedError < Faraday::Error::ClientError
+      attr_reader :response
+    
+      def initialize(response)
+        super "Access was denied."
+        @response = response
+      end
+    end
+  
+    class GuardServerError < Faraday::Response::Middleware
+      def on_complete(env)
+        if env[:status] == 500
+          if env[:body].match /Access is denied/
+            raise AccessDeniedError, env[:body]
+          else
+            raise InternalServerError, env[:body]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dwolla/response/parse_json.rb

@@ -0,0 +1,27 @@
+module Dwolla
+  module Response
+    class ParseJson < Faraday::Response::Middleware
+      def on_complete(env)
+        if respond_to? :parse
+          env[:body] = parse(env[:body]) unless [204,302,304,307].index env[:status]
+        end
+      end
+
+      def parse(body)
+        case body
+        when ''
+          nil
+        else
+          response_hash = ::MultiJson.load(body)
+
+          raise Dwolla::RequestException, response_hash["Message"] if response_hash["Success"] == false
+
+          response_hash["Response"] ||
+            response_hash["SendResult"] ||
+              response_hash["RequestResult"] ||
+                response_hash
+        end
+      end
+    end
+  end
+end

data/lib/dwolla/transaction.rb

@@ -0,0 +1,55 @@
+module Dwolla
+  class Transaction
+    include Dwolla::Connection
+    @test_mode = false
+    def self.test_mode
+      @test_mode
+    end
+    def self.test_mode=(m)
+      @test_mode = m
+    end
+
+    ENDPOINTS = { :send => 'transactions/send',
+                  :request => 'transactions/request' }
+    TEST_ENDPOINTS = { :send => 'testapi/send',
+                  :request => 'testapi/request' }
+
+    attr_accessor :origin, :destination, :destination_type, :type, :amount, :pin, :id, :source, :source_type, :description, :funds_source
+
+    def initialize(attrs = {})
+      attrs.each do |key, value|
+        send("#{key}=".to_sym, value)
+      end
+    end
+
+    def execute
+      if self.class.test_mode
+        end_point = TEST_ENDPOINTS[type]
+      else
+        end_point = ENDPOINTS[type]
+      end
+      self.id = post(end_point, to_payload)
+    end
+
+    private
+
+      def auth_params
+        { :oauth_token => origin.oauth_token }
+      end
+
+      def to_payload
+        payload = {
+          :amount => amount,
+          :pin => pin
+        }
+        payload[:destinationId] = destination if destination
+        payload[:destinationType] = destination_type if destination_type
+        payload[:sourceId] = source if source
+        payload[:sourceType] = source_type if source_type
+        payload[:notes] = description if description
+        payload[:fundsSource] = funds_source if funds_source
+
+        payload
+      end
+  end
+end

data/lib/dwolla/user.rb

@@ -0,0 +1,98 @@
+module Dwolla
+  class User
+    include Dwolla::Connection
+
+    attr_accessor :id,
+                  :name,
+                  :latitude,
+                  :longitude,
+                  :city,
+                  :state,
+                  :type,
+                  :contact_type,
+                  :image,
+                  :oauth_token
+
+    def initialize(attrs={})
+      update_attributes(attrs)
+    end
+
+    def self.me(access_token)
+      User.new(:oauth_token => access_token)
+    end
+
+    def fetch
+      user_attributes = get('users')
+      update_attributes(user_attributes)
+      self
+    end
+
+    def update_attributes(attrs)
+      attrs.each do |key, value|
+        key_string = key.is_a?(String) ? key : key.to_s
+        send("#{key_string.downcase}=".to_sym, value)
+      end
+    end
+
+    def balance
+      get('balance')
+    end
+    
+    def funding_sources
+      sources = get('fundingsources')
+      sources.map{|s| FundingSource.from_json(s)}
+    end
+
+    def funding_source(funding_id)
+      sources = get('fundingsources?fundingid=' + funding_id)
+      sources.map{|s| FundingSource.from_json(s)}
+    end
+
+    def contacts(options = {})
+      contacts_url = 'contacts'
+      contacts = get(contacts_url, options)
+
+      instances_from_contacts(contacts)
+    end
+
+    def send_money_to(destination, amount, pin, type='dwolla', description='', funds_source=nil)
+      transaction = Transaction.new(:origin => self,
+                                    :destination => destination,
+                                    :destination_type => type,
+                                    :description => description,
+                                    :type => :send,
+                                    :amount => amount,
+                                    :pin => pin,
+                                    :funds_source => funds_source)
+
+      transaction.execute
+    end
+
+    def request_money_from(source, amount, pin, source_type='dwolla', description='')
+      transaction = Transaction.new(:origin => self,
+                                    :source => source,
+                                    :source_type => source_type,
+                                    :description => description,
+                                    :type => :request,
+                                    :amount => amount,
+                                    :pin => pin)
+      transaction.execute
+    end
+
+    private
+
+      def instances_from_contacts(contacts)
+        user_instances = []
+        contacts.each do |contact|
+          contact["Contact_Type"] = contact["Type"]
+          contact.delete("Type")
+          user_instances << User.new(contact)
+        end
+        user_instances
+      end
+
+      def auth_params
+        { :oauth_token => self.oauth_token }
+      end
+   end
+end

data/lib/dwolla/version.rb

@@ -0,0 +1,3 @@
+module Dwolla
+  VERSION = "1.0.0"
+end

data/spec/dwolla/client_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Dwolla::Client do
+  subject { Dwolla::Client.new('sample_client_id', 'sample_client_secret') }
+  let(:query_params) { "client_id=sample_client_id&client_secret=sample_client_secret" }
+
+  describe "getting user basic information" do
+    before do
+      stub_get('/users/812-111-1111', query_params).
+        to_return(:body => fixture("basic_information.json"))
+    end
+
+    it 'should request the correct resource' do
+      subject.user('812-111-1111')
+      a_get('/users/812-111-1111', query_params).should have_been_made
+    end
+
+    it 'should return extended information of a given user' do
+      user = subject.user('812-111-1111')
+      user.should be_a Dwolla::User
+      user.id.should == '812-111-1111'
+      user.name.should == 'Test User'
+      user.latitude.should == 41.584546
+      user.longitude.should == -93.634167
+    end
+  end
+end

data/spec/dwolla/response/follow_redirects_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'forwardable'
+
+describe Dwolla::Response::FollowRedirects do
+
+ before do
+    @conn = Faraday.new do |b|
+      b.use Dwolla::Response::FollowRedirects
+      b.adapter :test do |stub|
+        stub.get('/') { [301, {'Location' => '/found'}, ''] }
+        stub.post('/create') { [302, {'Location' => '/'}, ''] }
+        stub.get('/found') { [200, {'Content-Type' => 'text/plain'}, 'fin'] }
+        stub.get('/loop') { [302, {'Location' => '/loop'}, ''] }
+        stub.get('/temp') { [307, {'Location' => '/found'}, ''] }
+      end
+    end
+  end
+
+  extend Forwardable
+  def_delegators :@conn, :get, :post
+  
+  it 'follow one redirect' do
+    get('/').body.should == 'fin'
+  end
+  
+  it 'follow twice redirect' do
+    post('/create').body.should == 'fin'
+  end
+
+  it 'follows 307 redirects' do
+    get('/temp').body.should == 'fin'
+  end
+  
+  it 'has a redirect limit' do
+    expect { get('/loop') }.to raise_error(Dwolla::Response::RedirectLimitReached)
+  end  
+end
+

data/spec/dwolla/transaction_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe Dwolla::Transaction do
+  describe "send transaction" do
+    context "to a dwolla account" do
+      before do
+        @origin = double(:oauth_token => '1')
+        @destination = '2'
+        @destination_type = "dwolla"
+        @payload = { :amount => 200,
+                     :pin => '1234',
+                     :destinationId => '2',
+                     :destinationType => 'dwolla',
+                     :notes => "Sending a transaction",
+                     :oauth_token => '1' }
+
+        stub_post('/transactions/send').with(:body => MultiJson.dump(@payload)).to_return(
+          :body => fixture('send_transaction.json'))
+      end
+      it "should request the correct resource" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :destination => @destination,
+                                              :destination_type => @destination_type,
+                                              :description => "Sending a transaction", 
+                                              :type => :send,
+                                              :amount => 200,
+                                              :pin => '1234')
+        transaction.execute
+
+        a_post('/transactions/send').
+          with(:body => MultiJson.dump(@payload)).should have_been_made
+      end
+
+      it "should fetch the id if transaction succesfull" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :destination => @destination,
+                                              :destination_type => @destination_type,
+                                              :description => "Sending a transaction",
+                                              :type => :send,
+                                              :amount => 200,
+                                              :pin => '1234')
+
+        transaction.execute.should == 12345
+        transaction.id.should == 12345
+      end 
+    end
+    
+    context "to an email address" do
+      before do
+        @origin = double(:oauth_token => '1')
+        @destination = "user@example.com"
+        @destination_type = "email"
+        @payload = { :amount => 200,
+                     :pin => '1234',
+                     :destinationId => 'user@example.com',
+                     :destinationType => 'email',
+                     :notes => "Sending a transaction",
+                     :oauth_token => '1' }
+        stub_post('/transactions/send').with(:body => MultiJson.dump(@payload)).to_return(
+                       :body => fixture('send_transaction.json'))
+      end
+      it "should request the correct resource" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :destination => @destination,
+                                              :destination_type => @destination_type,
+                                              :description => "Sending a transaction",
+                                              :type => :send,
+                                              :amount => 200,
+                                              :pin => '1234')
+                                              
+        transaction.execute
+
+        a_post('/transactions/send').
+          with(:body => MultiJson.dump(@payload)).should have_been_made
+      end
+
+      it "should fetch the id if transaction succesfull" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :destination => @destination,
+                                              :destination_type => @destination_type,
+                                              :description => "Sending a transaction",
+                                              :type => :send,
+                                              :amount => 200,
+                                              :pin => '1234')
+
+        transaction.execute.should == 12345
+        transaction.id.should == 12345
+      end
+    end
+
+  end
+
+  describe "request transaction" do
+    context "from a dwolla account" do
+      before do
+        @origin = double(:oauth_token => '1')
+        @source = '2'
+        @source_type = 'dwolla'
+        @payload = { :amount => 200,
+                     :pin => '1234',
+                     :sourceId => '2',
+                     :sourceType => 'dwolla',
+                     :notes => "Sending a transaction",
+                     :oauth_token => '1' }
+
+        stub_post('/transactions/request').with(:body => MultiJson.dump(@payload)).to_return(
+          :body => fixture('request_transaction.json'))
+      end
+
+      it "should request the correct resource" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :source => @source,
+                                              :source_type => @source_type,
+                                              :description => "Sending a transaction",
+                                              :type => :request,
+                                              :amount => 200,
+                                              :pin => '1234')
+        transaction.execute
+
+        a_post('/transactions/request').
+          with(:body => MultiJson.dump(@payload)).should have_been_made
+      end
+
+      it "should fetch the id if transaction succesfull" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :source => @source,
+                                              :source_type => @source_type,
+                                              :description => "Sending a transaction",
+                                              :type => :request,
+                                              :amount => 200,
+                                              :pin => '1234')
+
+        transaction.execute.should == 12345
+        transaction.id.should == 12345
+      end
+    end
+    context "from an email address" do
+      before do
+        @origin = double(:oauth_token => '1')
+        @source = 'user@example.com'
+        @source_type = "email"
+        @payload = { :amount => 200,
+                     :pin => '1234',
+                     :sourceId => 'user@example.com',
+                     :sourceType => 'email',
+                     :notes => "Sending a transaction",
+                     :oauth_token => '1' }
+
+        stub_post('/transactions/request').with(:body => MultiJson.dump(@payload)).to_return(
+          :body => fixture('request_transaction.json'))
+      end
+
+      it "should request the correct resource" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :source => @source,
+                                              :source_type => @source_type,
+                                              :description => "Sending a transaction",
+                                              :type => :request,
+                                              :amount => 200,
+                                              :pin => '1234')
+        transaction.execute
+
+        a_post('/transactions/request').
+          with(:body => MultiJson.dump(@payload)).should have_been_made
+      end
+
+      it "should fetch the id if transaction succesfull" do
+        transaction = Dwolla::Transaction.new(:origin => @origin,
+                                              :source => @source,
+                                              :source_type => @source_type,
+                                              :description => "Sending a transaction",
+                                              :type => :request,
+                                              :amount => 200,
+                                              :pin => '1234')
+
+        transaction.execute.should == 12345
+        transaction.id.should == 12345
+      end      
+    end
+  end
+end