spree_affirm 0.2.3

data/lib/active_merchant/billing/affirm.rb

@@ -0,0 +1,161 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class Affirm < Gateway
+      self.supported_countries = %w(US)
+      self.default_currency = 'USD'
+      self.money_format = :cents
+
+      def initialize(options = {})
+          requires!(options, :api_key, :secret_key, :server)
+          @api_key = options[:api_key]
+          @secret_key = options[:secret_key]
+          super
+      end
+
+      def set_charge(charge_id)
+          @charge_id = charge_id
+      end
+
+      def authorize(money, affirm_source, options = {})
+        result = commit(:post, "", {"checkout_token"=>affirm_source.token}, options, true)
+        return result unless result.success?
+
+        if amount(money).to_i != result.params["amount"].to_i
+          return Response.new(false,
+                              "Auth amount does not match charge amount",
+                              result.params
+                             )
+        elsif result.params["pending"].to_s != "true"
+          return Response.new(false,
+                              "There was an error authorizing this Charge",
+                              result.params
+                             )
+        end
+        result
+      end
+
+      # To create a charge on a card or a token, call
+      #
+      #   purchase(money, card_hash_or_token, { ... })
+      #
+      # To create a charge on a customer, call
+      #
+      #   purchase(money, nil, { :customer => id, ... })
+      def purchase(money, affirm_source, options = {})
+          result = authorize(money, affirm_source, options)
+          return result unless result.success?
+          capture(money, @charge_id, options)
+      end
+
+      def capture(money, charge_source, options = {})
+        post = {:amount => amount(money)}
+        set_charge(charge_source)
+        result = commit(:post, "#{@charge_id}/capture", post, options)
+        return result unless result.success?
+
+        if amount(money).to_i != result.params["amount"].to_i
+          return Response.new(false,
+                "Capture amount does not match charge amount",
+                result.params
+                )
+        end
+        result
+      end
+
+      def void(charge_source, options = {})
+        set_charge(charge_source)
+        commit(:post, "#{@charge_id}/void", {}, options)
+      end
+
+      def refund(money, charge_source, options = {})
+        post = {:amount => amount(money)}
+        set_charge(charge_source)
+        commit(:post, "#{@charge_id}/refund", post, options)
+      end
+
+      def credit(money, charge_source, options = {})
+          set_charge(charge_source)
+          return Response.new(true ,
+                       "Credited Zero amount",
+                       {},
+                       :authorization => @charge_id,
+                      ) unless money > 0
+          refund(money, charge_source, options)
+      end
+
+      def root_url
+        "#{root_api_url}charges/"
+      end
+
+      def root_api_url
+        "https://#{@options[:server]}/api/v2/"
+      end
+
+      def headers
+          {
+              "Content-Type" => "application/json",
+              "Authorization" => "Basic " + Base64.encode64(@api_key.to_s + ":" + @secret_key.to_s).gsub(/\n/, '').strip,
+              "User-Agent" => "Affirm/v1 ActiveMerchantBindings",
+          }
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def post_data(params)
+        return nil unless params
+        params.to_json
+      end
+
+      def response_error(raw_response)
+        begin
+          parse(raw_response)
+        rescue JSON::ParserError
+          json_error(raw_response)
+        end
+      end
+
+      def json_error(raw_response)
+        msg = 'Invalid response.  Please contact affirm if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{raw_response.inspect})"
+        {
+          "error" => {
+            "message" => msg
+          }
+        }
+      end
+
+      def get_checkout(checkout_token)
+        _url           = root_api_url + "checkout/#{checkout_token}"
+        _raw_response  = ssl_request :get, _url, nil, headers
+
+        parse(_raw_response)
+      end
+
+      def commit(method, url, parameters=nil, options = {}, ret_charge=false)
+          raw_response = response = nil
+          success = false
+          begin
+              raw_response = ssl_request(method, root_url + url, post_data(parameters), headers)
+              response = parse(raw_response)
+              success = !response.key?("status_code") && (!ret_charge || response.key?("id"))
+          rescue ResponseError => e
+              raw_response = e.response.body
+              response = response_error(raw_response)
+          rescue JSON::ParserError
+              response = json_error(raw_response)
+          end
+
+          if success && ret_charge
+              @charge_id = response["id"]
+          end
+          Response.new(success,
+                       success ? "Transaction approved" : response["message"],
+                       response,
+                       :authorization => @charge_id,
+                      )
+      end
+    end
+  end
+end

data/lib/generators/spree_affirm/install/install_generator.rb

@@ -0,0 +1,21 @@
+module SpreeAffirm
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+
+      class_option :auto_run_migrations, :type => :boolean, :default => false
+
+      def add_migrations
+        run 'bundle exec rake railties:install:migrations FROM=spree_affirm'
+      end
+
+      def run_migrations
+        run_migrations = options[:auto_run_migrations] || ['', 'y', 'Y'].include?(ask 'Would you like to run the migrations now? [Y/n]')
+        if run_migrations
+          run 'bundle exec rake db:migrate'
+        else
+          puts 'Skipping rake db:migrate, don\'t forget to run it!'
+        end
+      end
+    end
+  end
+end

data/lib/spree_affirm/engine.rb

@@ -0,0 +1,27 @@
+module SpreeAffirm
+  class Engine < Rails::Engine
+    require 'spree/core'
+    isolate_namespace Spree
+    engine_name 'spree_affirm'
+
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+
+    config.autoload_paths += %W(#{config.root}/lib)
+
+    def self.activate
+      Dir.glob(File.join(File.dirname(__FILE__), '../../app/**/*_decorator*.rb')) do |c|
+        Rails.configuration.cache_classes ? require(c) : load(c)
+      end
+    end
+
+    config.to_prepare &method(:activate).to_proc
+
+    initializer "spree.spree_affirm.payment_methods", :after => "spree.register.payment_methods" do |app|
+        app.config.spree.payment_methods << Spree::Gateway::Affirm
+    end
+  end
+end

data/lib/spree_affirm/factories/affirm_checkout_factory.rb

@@ -0,0 +1,211 @@
+def BASE_CHECKOUT_DETAILS
+  {
+    "merchant"=> {
+      "public_api_key"=> "PPPPPPPPPPPPPPP",
+      "user_cancel_url"=> "http=>//google.com/cancel",
+      "user_confirmation_url"=> "http=>//google.com/confirm",
+      "name"=> "Test Merchant"
+    },
+    "tax_amount"=> 0,
+    "billing"=> {
+      "address"=> {
+        "city"=> "San Francisco",
+        "street1"=> "12345 Main",
+        "street2"=> "300",
+        "region1_code"=> "AL",
+        "postal_code"=> "55555",
+        "country_code"=> "USA",
+        "for_billing"=> true,
+        "validation_source"=> 3
+      },
+      "email"=> "test@affirm.com",
+      "name"=> {
+        "for_billing"=> true,
+        "last"=> "Doe",
+        "first"=> "John"
+      }
+    },
+    "items"=> {
+      "xxx-xx-xxx-x"=> {
+        "sku"=> "xxx-xx-xxx-x",
+        "item_url"=> "http=>//google.com/products/the-blue-hat",
+        "display_name"=> "The Blue Hat",
+        "unit_price"=> 85000,
+        "qty"=> 1,
+        "item_type"=> "physical",
+        "item_image_url"=> "http=>//google.com/products/6/large/the-blue-hat"
+      }
+    },
+    "shipping"=> {
+      "name"=> {
+        "last"=> "Doe",
+        "first"=> "John"
+      },
+      "address"=> {
+        "city"=> "San Francisco",
+        "street1"=> "12345 Main Street",
+        "street2"=> "300",
+        "region1_code"=> "AL",
+        "postal_code"=> "94110",
+        "country_code"=> "USA",
+        "validation_source"=> 3
+      }
+    },
+    "checkout_id"=> "S123123-456",
+    "currency"=> "USD",
+    "meta"=> {
+      "release"=> "true",
+      "user_timezone"=> "America/Los_Angeles",
+      "__affirm_tracking_uuid"=> "97570a41-cd07-4f52-8869-46c6d2588407"
+    },
+    "discount_code"=> "",
+    "misc_fee_amount"=> 0,
+    "shipping_type"=> "Free National UPS",
+    "config"=> {
+      "required_billing_fields"=> [
+        "name",
+        "address",
+        "email"
+      ]
+    },
+    "api_version"=> "v2",
+    "shipping_amount"=> 0
+  }
+end
+
+FactoryGirl.define do
+  factory :affirm_checkout, class: Spree::AffirmCheckout do
+    token "12345678910"
+    association(:payment_method, factory: :affirm_payment_method)
+    association(:order, factory: :order_with_line_items)
+
+
+    transient do
+      stub_details true
+      shipping_address_mismatch false
+      billing_address_mismatch false
+      alternate_billing_address_format false
+      billing_address_full_name false
+      billing_email_mismatch false
+      extra_line_item false
+      missing_line_item false
+      quantity_mismatch false
+      price_mismatch false
+      full_name_case_mismatch false
+    end
+
+    after(:build) do |checkout, evaluator|
+
+      _details = BASE_CHECKOUT_DETAILS()
+
+      # case mismatch
+      unless evaluator.full_name_case_mismatch
+        _details['billing']['name'] = {
+          "full" => checkout.order.bill_address.firstname.upcase + " " +
+                    checkout.order.bill_address.lastname.upcase
+        }
+      end
+
+      # shipping address
+      unless evaluator.shipping_address_mismatch
+        _details['shipping'] = {
+          "name" => {
+            "first" => checkout.order.ship_address.firstname,
+            "last"  => checkout.order.ship_address.lastname
+          },
+          "address"=> {
+            "city"=> checkout.order.ship_address.city,
+            "street1"=> checkout.order.ship_address.address1,
+            "street2"=> checkout.order.ship_address.address2,
+            "region1_code"=> checkout.order.ship_address.state.abbr,
+            "postal_code"=> checkout.order.ship_address.zipcode,
+            "country_code"=> checkout.order.ship_address.country.iso3
+          }
+        }
+      end
+
+      # billing address
+      unless evaluator.billing_address_mismatch
+        _details["billing"] = {
+          "email" => "joe@schmoe.com",
+          "name" => {
+            "first" => checkout.order.bill_address.firstname,
+            "last"  => checkout.order.bill_address.lastname
+          },
+          "address"=> {
+            "city"=> checkout.order.bill_address.city,
+            "street1"=> checkout.order.bill_address.address1,
+            "street2"=> checkout.order.bill_address.address2,
+            "region1_code"=> checkout.order.bill_address.state.abbr,
+            "postal_code"=> checkout.order.bill_address.zipcode,
+            "country_code"=> checkout.order.bill_address.country.iso3
+          }
+        }
+      end
+
+      # use alternate format for billing address
+      if evaluator.alternate_billing_address_format
+        _details['billing']["address"] = {
+          "city" => _details['billing']["address"]["city"],
+          "line1"=> _details['billing']["address"]["street1"],
+          "line2"=> _details['billing']["address"]["street2"],
+          "state"=> _details['billing']["address"]["postal_code"],
+          "zipcode"=> _details['billing']["address"]["region1_code"],
+          "country"=> _details['billing']["address"]["country_code"]
+        }
+      end
+
+      # use name.full instead of first/last
+      if evaluator.billing_address_full_name
+        _details['billing']['name'] = {
+          'full' => "#{_details['billing']['name']['first']} #{_details['billing']['name']['last']}"
+        }
+      end
+
+
+      # billing email
+      unless evaluator.billing_email_mismatch
+        _details["billing"]["email"] = checkout.order.email
+      end
+
+      # setup items in cart
+      _details['items'] = {}
+      checkout.order.line_items.each do |item|
+        _details['items'][item.variant.sku] = {
+          "qty" => item.quantity.to_s,
+          "unit_price" => (item.price*100).to_s,
+          "display_name" => item.product.name
+        }
+      end
+
+      if evaluator.extra_line_item
+        _details['items']['extra-1-2-3'] = {
+          "qty" => "1",
+          "unit_price" => "12300",
+          "display_name" => "Really cool hat"
+        }
+      end
+
+      if evaluator.missing_line_item
+        _details['items'].delete _details['items'].keys.last
+      end
+
+      if evaluator.quantity_mismatch
+        _last_item = _details['items'][_details['items'].keys.last]
+        _details['items'][_details['items'].keys.last]['qty'] = (_last_item['qty'].to_i + 1).to_s
+      end
+
+      if evaluator.price_mismatch
+        _last_item = _details['items'][_details['items'].keys.last]
+        _details['items'][_details['items'].keys.last]['unit_price'] = 456456
+      end
+
+      if evaluator.stub_details
+        checkout.stub(details: _details)
+      end
+    end
+
+  end
+end
+
+

data/lib/spree_affirm/factories/affirm_payment_method_factory.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :affirm_payment_method, class: Spree::Gateway::Affirm do
+    name "Staging Affirm Split Pay"
+    active true
+    environment "test"
+    auto_capture false
+  end
+end

data/lib/spree_affirm/factories/payment_factory.rb

@@ -0,0 +1,10 @@
+FactoryGirl.define do
+  factory :affirm_payment, class: Spree::Payment do
+    amount 45.75
+    association(:payment_method, factory: :affirm_payment_method)
+    association(:source, factory: :affirm_checkout)
+    order
+    state 'checkout'
+    response_code '12345'
+  end
+end

data/lib/spree_affirm/factories.rb

@@ -0,0 +1,5 @@
+require 'factory_girl'
+
+Dir["#{File.dirname(__FILE__)}/factories/**"].each do |f|
+  require File.expand_path(f)
+end

data/lib/spree_affirm/version.rb

@@ -0,0 +1,3 @@
+module SpreeAffirm
+  VERSION = "0.2.3"
+end

data/lib/spree_affirm.rb

@@ -0,0 +1,2 @@
+require 'spree_core'
+require 'spree_affirm/engine'

data/spec/controllers/affirm_controller_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe Spree::AffirmController do
+  let(:user) { FactoryGirl.create(:user) }
+  let(:checkout) { FactoryGirl.build(:affirm_checkout) }
+  let(:bad_billing_checkout) { FactoryGirl.build(:affirm_checkout, billing_address_mismatch: true) }
+  let(:bad_shipping_checkout) { FactoryGirl.build(:affirm_checkout, shipping_address_mismatch: true) }
+  let(:bad_email_checkout) { FactoryGirl.build(:affirm_checkout, billing_email_mismatch: true) }
+
+
+  describe "POST confirm" do
+
+    def post_request(token, payment_id)
+      post :confirm, checkout_token: token, payment_method_id: payment_id, use_route: 'spree'
+    end
+
+    before do
+      controller.stub authenticate_spree_user!: true
+      controller.stub spree_current_user: user
+    end
+
+    context "when the checkout matches the order" do
+      before do
+        Spree::AffirmCheckout.stub new: checkout
+        controller.stub current_order: checkout.order
+      end
+
+      context "when no checkout_token is provided" do
+        it "redirects to the current order state" do
+          post_request(nil, nil)
+          expect(response).to redirect_to(controller.checkout_state_path(checkout.order.state))
+        end
+      end
+
+      context "when the order is complete" do
+        before do
+          checkout.order.state = 'complete'
+        end
+        it "redirects to the current order state" do
+          post_request '123456789', checkout.payment_method.id
+          expect(response).to redirect_to(controller.order_path(checkout.order))
+        end
+      end
+
+      context "when the order state is payment" do
+        before do
+          checkout.order.state = 'payment'
+        end
+
+        it "creates a new payment" do
+          post_request "123423423", checkout.payment_method.id
+
+          expect(checkout.order.payments.first.source).to eq(checkout)
+        end
+
+        # it "transitions to complete if confirmation is not required" do
+        #   checkout.order.stub confirmation_required?: false
+        #   post_request "123423423", checkout.payment_method.id
+
+        #   expect(checkout.order.state).to eq("complete")
+        # end
+
+        it "transitions to confirm if confirmation is required" do
+          checkout.order.stub confirmation_required?: true
+          post_request "123423423", checkout.payment_method.id
+
+          expect(checkout.order.reload.state).to eq("confirm")
+        end
+      end
+
+    end
+
+    context "when the billing_address does not match the order" do
+      before do
+        Spree::AffirmCheckout.stub new: bad_billing_checkout
+        state = FactoryGirl.create(:state, abbr: bad_billing_checkout.details['billing']['address']['region1_code'])
+        Spree::State.stub find_by_abbr: state, find_by_name: state
+        controller.stub current_order: bad_billing_checkout.order
+      end
+
+      it "creates a new address record for the order" do
+        _old_billing_address = bad_billing_checkout.order.bill_address
+        post_request '12345789', bad_billing_checkout.payment_method.id
+
+        expect(bad_billing_checkout.order.bill_address).not_to be(_old_billing_address)
+        expect(bad_billing_checkout.valid?).to be(true)
+      end
+    end
+
+
+    context "when the shipping_address does not match the order" do
+      before do
+        Spree::AffirmCheckout.stub new: bad_shipping_checkout
+        state = FactoryGirl.create(:state, abbr: bad_shipping_checkout.details['shipping']['address']['region1_code'])
+        Spree::State.stub find_by_abbr: state, find_by_name: state
+        controller.stub current_order: bad_shipping_checkout.order
+      end
+
+      it "creates a new address record for the order" do
+        _old_shipping_address = bad_shipping_checkout.order.ship_address
+        post_request '12345789', bad_shipping_checkout.payment_method.id
+
+        expect(bad_shipping_checkout.order.ship_address).not_to be(_old_shipping_address)
+        expect(bad_shipping_checkout.valid?).to be(true)
+      end
+    end
+
+
+
+    context "when the billing_email does not match the order" do
+      before do
+        Spree::AffirmCheckout.stub new: bad_email_checkout
+        controller.stub current_order: bad_email_checkout.order
+      end
+
+      it "updates the billing_email on the order" do
+        _old_email = bad_email_checkout.order.email
+        post_request '12345789', bad_email_checkout.payment_method.id
+
+        expect(bad_email_checkout.order.email).not_to be(_old_email)
+        expect(bad_email_checkout.valid?).to be(true)
+      end
+    end
+
+
+    context "there is no current order" do
+      before(:each) do
+        controller.stub current_order: nil
+      end
+
+      it "raises an ActiveRecord::RecordNotFound error" do
+        expect do
+          post_request nil, nil
+        end.to raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+  end
+end