spree_paypal_express 1.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.swp
+.DS_store
+spec/test_app
+spec/dummy
+.rvmrc
+.bundle
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,14 @@
+before_script:
+  - "export DISPLAY=:99.0"
+  - "sh -e /etc/init.d/xvfb start"
+  - "DISPLAY=:99.0 bundle exec rake test_app"
+script: "DISPLAY=:99.0 bundle exec rspec spec"
+notifications:
+  email:
+    - briandquinn@gmail.com
+branches:
+  only:
+    - master
+    - 1-1-stable
+rvm:
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+Redistribution and use in source and binary forms, with or without modification, 
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, 
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, 
+      this list of conditions and the following disclaimer in the documentation 
+      and/or other materials provided with the distribution.
+    * Neither the name of the Rails Dog LLC nor the names of its 
+      contributors may be used to endorse or promote products derived from this 
+      software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.markdown

@@ -0,0 +1,146 @@
+# Official PayPal Express for Spree
+
+[![Build Status](https://secure.travis-ci.org/spree/spree_paypal_express.png?branch=master)](http://travis-ci.org/spree/spree_paypal_express)
+
+This is the official PayPal Express extension for Spree, based on the extension by PaulCC it has been extended to support Spree's
+Billing Integrations which allows users to configure the PayPal Express gateway including API login / password and signatures fields
+via the Admin UI.
+
+This extension allows the store to use PayPal Express from two locations:
+
+  1. Checkout Payment - When configured the PayPal Express checkout button will appear alongside the standard credit card payment
+  options on the payment stage of the standard checkout. The selected shipping address and shipping method / costs are automatically
+  sent to the PayPal review page (along with detailed order information).
+
+  
+  2. Cart Checkout (THIS FEATURE IS NOT YET COMPLETE) - Presents the PayPal checkout button on the users Cart page and redirects the user to complete
+  all shipping / addressing information on PaypPal's site. This also supports PayPal's Instant Update feature to retrieve shipping options live from 
+  Spree when the user selects / changes their shipping address on PayPal's site.
+
+This extension follows the documented flow for a PayPal Express Checkout, where a user is forwarded to PayPal to allow them to login and review
+the order (possibly select / change shipping address and method), then the user is redirected back to Spree to confirm the order. The user
+MUST confirm the order on the Spree site before the payment is authorized / captured from PayPal (and the order is transitioned to the New state).
+
+
+Installation
+============
+
+1. Add the following line to your application's Gemfile
+
+     gem "spree_paypal_express", :git => "git://github.com/spree/spree_paypal_express.git"
+
+**Note:** The :git option is only required for the edge version, and can be removed to used the released gem.
+
+2. Install the gem using Bundler:
+
+    bundle install
+
+3. Copy & run migrations
+
+    bundle exec rails g spree_paypal_express:install
+
+Versions
+========
+
+To determine the correct version of this extension, please refer to the Versionfile.
+
+IPN & eCheck Support
+===================
+eCheck payments are now fully supported and PayPal's Instant Payment Notification service is also supported for receiving updates relating to eCheck payments only. To configure eCheck payments you'll need to:
+
+1. Configure your PayPal account to accept eCheck payments (under Profile on PayPal's website).
+
+2. Set the IPN URL on your PayPal account (under Profile on PayPal's website) to:
+
+     https://www.yourstore.com/paypal_notify
+
+3. Enable auto_capture within Spree (as eCheck payments are only supported for purchase and not authorize requests).
+
+     Spree::Config.set(:auto_capture => true)
+
+
+
+Configuration
+=============
+
+1. Before you begin
+  
+You'll need to have a Paypal developer account (developer.paypal.com) and both buyer and seller test accounts.
+  
+**Tip:** these are sandbox only, so use email addresses and passwords that are easy to  remember, e.g. buyer@example.com and seller@example.com.
+  
+Your sandbox credentials are available from the API Credentials link.
+
+2. Setup the Payment Method
+  
+Log in as an admin and add a new **Payment Method** (under Configuration), using following details:
+
+**Name:** Paypal Express
+  
+**Environment:** Development (or what ever environment you prefer)
+  
+**Active:** Yes
+  
+**Provider:** Spree::BillingIntegration::PaypalExpress
+  
+Click **Create* , and now add your credentials in the screen that follows:
+  
+**Review:** unchecked [1]
+  
+**Signature:** API signature from your paypal seller test account
+  
+**Server:** test (for Development or live for Production)
+  
+**Test Mode:** checked (or unchecked for Production)
+  
+**Password:** API Password from your paypal seller test account
+  
+**Login:** API Username from your paypal seller test account (care to use the API Username and not the Test Account address)
+  
+Click **Update**
+
+Test Drive
+==========
+
+While testing PayPal Express checkout locally make sure you're logged into your PayPal **developer** account in another browser window before attempting a PayPal payment, as you'll be redirected and forced to sign in to your developer account.
+
+1. Add an item to cart
+  
+2. Check out
+  
+3. Address step: complete it using a valid US address.
+  
+4. Delivery step: pick anything
+  
+5. On the Payment Step, you should see a PayPal button. You can select it directly or just click "Continue"
+  
+6. You will get redirected to PayPals sandbox site, be sure to log in as a **Buyer** / **Personal** test account and not the account you use to configure the Payment Method with. 
+  
+7. You should now see the paypal order details screen with a Pay Now button.
+  
+8. Click Pay Now, and you should now be redirected back to Spree's order thank you page.
+  
+9. Log into the Admin UI and review the Order and Payment details to confirm the successful checkout.
+
+
+Running Specs
+=============
+
+1. Create Test App
+
+    rake test_app
+
+2. Run Specs
+
+    rake spec
+
+NOTES
+=====
+    
+To automatically capture funds or enable accepting eCheck payments, add this to you site extension's activate method:
+
+    if Spree::Config.instance
+      Spree::Config[:auto_capture] = true
+    end
+    
+[1] If you check the review checkbox in the admin section for Payment Methods/Paypal Express, the flow is slightly different. Instead of Pay Now on Paypal's order details page, it now says Continue. And the user is directed back to the spree app's Confirmation page showing a place order button. Use whichever suits your needs best. Personally, I leave review unchecked to cut down on the steps in the checkout flow.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake'
+require 'rspec/core/rake_task'
+require 'spree/core/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default => [:spec ]
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_paypal_express'
+  Rake::Task['common:test_app'].invoke
+end

data/Versionfile

@@ -0,0 +1,5 @@
+"1.1.0"  => { :branch => "1-1-stable" }
+"1.0.0"  => { :branch => "1-0-stable" }
+"0.70.x" => { :ref => "bea1aa48e0089083546bec4b19565a40e9a50a20" }
+"0.60.x" => { :ref => "073f2f814dd8f3ad2e66ddde2c7079d8c76e4d27" }
+"0.50.x" => { :ref => "39a3b00602d591e5c27bf13941aa5c13e4b95579" }

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,384 @@
+module Spree
+  CheckoutController.class_eval do
+    before_filter :redirect_to_paypal_express_form_if_needed, :only => [:update]
+
+    def paypal_checkout
+      load_order
+      opts = all_opts(@order, params[:payment_method_id], 'checkout')
+      opts.merge!(address_options(@order))
+      @gateway = paypal_gateway
+
+      if Spree::Config[:auto_capture]
+        @ppx_response = @gateway.setup_purchase(opts[:money], opts)
+      else
+        @ppx_response = @gateway.setup_authorization(opts[:money], opts)
+      end
+
+      unless @ppx_response.success?
+        gateway_error(@ppx_response)
+        redirect_to edit_order_url(@order)
+        return
+      end
+
+      redirect_to(@gateway.redirect_url_for(response.token, :review => payment_method.preferred_review))
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
+      redirect_to :back
+    end
+
+    def paypal_payment
+      load_order
+      opts = all_opts(@order,params[:payment_method_id], 'payment')
+      opts.merge!(address_options(@order))
+      @gateway = paypal_gateway
+
+      if Spree::Config[:auto_capture]
+        @ppx_response = @gateway.setup_purchase(opts[:money], opts)
+      else
+        @ppx_response = @gateway.setup_authorization(opts[:money], opts)
+      end
+
+      unless @ppx_response.success?
+        gateway_error(@ppx_response)
+        redirect_to edit_order_checkout_url(@order, :state => "payment")
+        return
+      end
+
+      redirect_to(@gateway.redirect_url_for(@ppx_response.token, :review => payment_method.preferred_review))
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
+      redirect_to :back
+    end
+
+    def paypal_confirm
+      load_order
+
+      opts = { :token => params[:token], :payer_id => params[:PayerID] }.merge all_opts(@order, params[:payment_method_id],  'payment')
+      gateway = paypal_gateway
+
+      @ppx_details = gateway.details_for params[:token]
+
+      if @ppx_details.success?
+        # now save the updated order info
+
+        Spree::PaypalAccount.create(:email => @ppx_details.params["payer"],
+                                    :payer_id => @ppx_details.params["payer_id"],
+                                    :payer_country => @ppx_details.params["payer_country"],
+                                    :payer_status => @ppx_details.params["payer_status"])
+
+        @order.special_instructions = @ppx_details.params["note"]
+
+        unless payment_method.preferred_no_shipping
+          ship_address = @ppx_details.address
+          order_ship_address = Spree::Address.new :firstname  => @ppx_details.params["first_name"],
+                                                  :lastname   => @ppx_details.params["last_name"],
+                                                  :address1   => ship_address["address1"],
+                                                  :address2   => ship_address["address2"],
+                                                  :city       => ship_address["city"],
+                                                  :country    => Spree::Country.find_by_iso(ship_address["country"]),
+                                                  :zipcode    => ship_address["zip"],
+                                                  # phone is currently blanked in AM's PPX response lib
+                                                  :phone      => @ppx_details.params["phone"] || "(not given)"
+
+          if (state = Spree::State.find_by_abbr(ship_address["state"].upcase))
+            order_ship_address.state = state
+          else
+            order_ship_address.state_name = ship_address["state"]
+          end
+          order_ship_address.save!
+
+          @order.ship_address = order_ship_address
+          @order.bill_address ||= order_ship_address
+        end
+        @order.state = "payment"
+        @order.save
+
+        if payment_method.preferred_review
+          @order.next
+          render 'spree/shared/paypal_express_confirm'
+        else
+          paypal_finish
+        end
+
+      else
+        gateway_error(@ppx_details)
+
+        #Failed trying to get payment details from PPX
+        redirect_to edit_order_checkout_url(@order, :state => "payment")
+      end
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
+      redirect_to edit_order_url(@order)
+    end
+
+    def paypal_finish
+      load_order
+
+      opts = { :token => params[:token], :payer_id => params[:PayerID] }.merge all_opts(@order, params[:payment_method_id], 'payment' )
+      gateway = paypal_gateway
+
+      method = Spree::Config[:auto_capture] ? :purchase : :authorize
+      ppx_auth_response = gateway.send(method, (@order.total*100).to_i, opts)
+
+      paypal_account = Spree::PaypalAccount.find_by_payer_id(params[:PayerID])
+
+      payment = @order.payments.create(
+        :amount => ppx_auth_response.params["gross_amount"].to_f,
+        :source => paypal_account,
+        :source_type => 'Spree::PaypalAccount',
+        :payment_method_id => params[:payment_method_id],
+        :response_code => ppx_auth_response.authorization,
+        :avs_response => ppx_auth_response.avs_result["code"])
+
+      payment.started_processing!
+
+      record_log payment, ppx_auth_response
+
+      if ppx_auth_response.success?
+        #confirm status
+        case ppx_auth_response.params["payment_status"]
+        when "Completed"
+          payment.complete!
+        when "Pending"
+          payment.pend!
+        else
+          payment.pend!
+          Rails.logger.error "Unexpected response from PayPal Express"
+          Rails.logger.error ppx_auth_response.to_yaml
+        end
+
+        @order.update_attributes({:state => "complete", :completed_at => Time.now}, :without_protection => true)
+
+        state_callback(:after) # So that after_complete is called, setting session[:order_id] to nil
+
+        # Since we dont rely on state machine callback, we just explicitly call this method for spree_store_credits
+        if @order.respond_to?(:consume_users_credit, true)
+          @order.send(:consume_users_credit)
+        end
+
+        @order.finalize!
+        flash[:notice] = I18n.t(:order_processed_successfully)
+        redirect_to completion_route
+
+      else
+        payment.failure!
+        order_params = {}
+        gateway_error(ppx_auth_response)
+
+        #Failed trying to complete pending payment!
+        redirect_to edit_order_checkout_url(@order, :state => "payment")
+      end
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
+      redirect_to edit_order_url(@order)
+    end
+
+    private
+
+    def asset_url(_path)
+      URI::HTTP.build(:path => ActionController::Base.helpers.asset_path(_path), :host => Spree::Config[:site_url]).to_s
+    end
+
+    def record_log(payment, response)
+      payment.log_entries.create(:details => response.to_yaml)
+    end
+
+    def redirect_to_paypal_express_form_if_needed
+      return unless (params[:state] == "payment")
+      return unless params[:order][:payments_attributes]
+
+      if @order.update_attributes(object_params)
+        if params[:order][:coupon_code] and !params[:order][:coupon_code].blank? and @order.coupon_code.present?
+          fire_event('spree.checkout.coupon_code_added', :coupon_code => @order.coupon_code)
+        end
+      end
+
+      load_order
+      payment_method = Spree::PaymentMethod.find(params[:order][:payments_attributes].first[:payment_method_id])
+
+      if payment_method.kind_of?(Spree::BillingIntegration::PaypalExpress) || payment_method.kind_of?(Spree::BillingIntegration::PaypalExpressUk)
+        redirect_to(paypal_payment_order_checkout_url(@order, :payment_method_id => payment_method.id)) and return
+      end
+    end
+
+    def fixed_opts
+      if Spree::PaypalExpress::Config[:paypal_express_local_confirm].nil?
+        user_action = "continue"
+      else
+        user_action = Spree::PaypalExpress::Config[:paypal_express_local_confirm] == "t" ? "continue" : "commit"
+      end
+
+      #asset_url doesn't like Spree::Config[:logo] being an absolute url
+      #if statement didn't work within hash
+      if URI.parse(Spree::Config[:logo]).absolute?
+          chosen_image = Spree::Config[:logo]
+      else
+          chosen_image = asset_url(Spree::Config[:logo])
+      end
+
+
+      { :description             => "Goods from #{Spree::Config[:site_name]}", # site details...
+        #:page_style             => "foobar", # merchant account can set named config
+        :background_color        => "ffffff",  # must be hex only, six chars
+        :header_background_color => "ffffff",
+        :header_border_color     => "ffffff",
+  :header_image    => chosen_image,
+        :allow_note              => true,
+        :locale                  => user_locale,
+        :req_confirm_shipping    => false,   # for security, might make an option later
+        :user_action             => user_action
+
+        # WARNING -- don't use :ship_discount, :insurance_offered, :insurance since
+        # they've not been tested and may trigger some paypal bugs, eg not showing order
+        # see http://www.pdncommunity.com/t5/PayPal-Developer-Blog/Displaying-Order-Details-in-Express-Checkout/bc-p/92902#C851
+      }
+    end
+
+    def user_locale
+      I18n.locale.to_s
+    end
+
+    # hook to override paypal site options
+    def paypal_site_opts
+      {:currency => payment_method.preferred_currency, :allow_guest_checkout => payment_method.preferred_allow_guest_checkout }
+    end
+
+    def order_opts(order, payment_method, stage)
+      items = order.line_items.map do |item|
+        price = (item.price * 100).to_i # convert for gateway
+        { :name        => item.variant.product.name,
+          :description => (item.variant.product.description[0..120] if item.variant.product.description),
+          :number      => item.variant.sku,
+          :quantity    => item.quantity,
+          :amount      => price,
+          :weight      => item.variant.weight,
+          :height      => item.variant.height,
+          :width       => item.variant.width,
+          :depth       => item.variant.weight }
+        end
+
+      credits = order.adjustments.eligible.map do |credit|
+        if credit.amount < 0.00
+          { :name        => credit.label,
+            :description => credit.label,
+            :sku         => credit.id,
+            :quantity    => 1,
+            :amount      => (credit.amount*100).to_i }
+        end
+      end
+
+      credits_total = 0
+      credits.compact!
+      if credits.present?
+        items.concat credits
+        credits_total = credits.map {|i| i[:amount] * i[:quantity] }.sum
+      end
+
+      opts = { :return_url        => paypal_confirm_order_checkout_url(order, :payment_method_id => payment_method),
+               :cancel_return_url => edit_order_checkout_url(order, :state => :payment),
+               :order_id          => order.number,
+               :custom            => order.number,
+               :items             => items,
+               :subtotal          => ((order.item_total * 100) + credits_total).to_i,
+               :tax               => (order.tax_total*100).to_i,
+               :shipping          => (order.ship_total*100).to_i,
+               :money             => (order.total * 100 ).to_i }
+
+      if stage == "checkout"
+        opts[:handling] = 0
+
+        opts[:callback_url] = spree_root_url + "paypal_express_callbacks/#{order.number}"
+        opts[:callback_timeout] = 3
+      elsif stage == "payment"
+        #hack to add float rounding difference in as handling fee - prevents PayPal from rejecting orders
+        #because the integer totals are different from the float based total. This is temporary and will be
+        #removed once Spree's currency values are persisted as integers (normally only 1c)
+        opts[:handling] =  (order.total*100).to_i - opts.slice(:subtotal, :tax, :shipping).values.sum
+      end
+
+      opts
+    end
+
+    def address_options(order)
+      if payment_method.preferred_no_shipping
+        { :no_shipping => true }
+      else
+        {
+          :no_shipping => false,
+          :address_override => true,
+          :address => {
+            :name       => "#{order.ship_address.firstname} #{order.ship_address.lastname}",
+            :address1   => order.ship_address.address1,
+            :address2   => order.ship_address.address2,
+            :city       => order.ship_address.city,
+            :state      => order.ship_address.state.nil? ? order.ship_address.state_name.to_s : order.ship_address.state.abbr,
+            :country    => order.ship_address.country.iso,
+            :zip        => order.ship_address.zipcode,
+            :phone      => order.ship_address.phone
+          }
+        }
+      end
+    end
+
+    def all_opts(order, payment_method, stage=nil)
+      opts = fixed_opts.merge(order_opts(order, payment_method, stage)).merge(paypal_site_opts)
+
+      if stage == "payment"
+        opts.merge! flat_rate_shipping_and_handling_options(order, stage)
+      end
+
+      # suggest current user's email or any email stored in the order
+      opts[:email] = current_user ? current_user.email : order.email
+
+      opts
+    end
+
+    # hook to allow applications to load in their own shipping and handling costs
+    def flat_rate_shipping_and_handling_options(order, stage)
+      # max_fallback = 0.0
+      # shipping_options = ShippingMethod.all.map do |shipping_method|
+      #       max_fallback = shipping_method.fallback_amount if shipping_method.fallback_amount > max_fallback
+      #           { :name       => "#{shipping_method.id}",
+      #             :label       => "#{shipping_method.name} - #{shipping_method.zone.name}",
+      #             :amount      => (shipping_method.fallback_amount*100) + 1,
+      #             :default     => shipping_method.is_default }
+      #         end
+      #
+      #
+      # default_shipping_method = ShippingMethod.find(:first, :conditions => {:is_default => true})
+      #
+      # opts = { :shipping_options  => shipping_options,
+      #          :max_amount  => (order.total + max_fallback)*100
+      #        }
+      #
+      # opts[:shipping] = (default_shipping_method.nil? ? 0 : default_shipping_method.fallback_amount) if stage == "checkout"
+      #
+      # opts
+      {}
+    end
+
+    def gateway_error(response)
+      if response.is_a? ActiveMerchant::Billing::Response
+        text = response.params['message'] ||
+               response.params['response_reason_text'] ||
+               response.message
+      else
+        text = response.to_s
+      end
+
+      msg = "#{I18n.t('gateway_error')}: #{text}"
+      logger.error(msg)
+      flash[:error] = msg
+    end
+
+    # create the gateway from the supplied options
+    def payment_method
+      @payment_method ||= Spree::PaymentMethod.find(params[:payment_method_id])
+    end
+
+    def paypal_gateway
+      payment_method.provider
+    end
+
+  end
+end