solidus_active_shipping 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d467e39dfb8748765167db0bdb9537def5474d06
+  data.tar.gz: dbec361b367ebe9a75b8fcb1f63bdf440432fe62
+SHA512:
+  metadata.gz: ea5a385c0ac36f65ff5381281ef11e7ed0ad5dd51878fdabe89d236b6827635759bffe48e94e1c5c155eed5be8d506daa304fd045aa2910c2ddbeacb6dc82d05
+  data.tar.gz: ffc02cdc9744b9bf64e8cb4c7a1c075c76ca542b05583e509606ee6a50f1b00eec445da5c444d86c3e303591609e157e9381c32c538546fa2b9f50de8022267c

data/.gitignore

@@ -0,0 +1,11 @@
+spec/test_app
+spec/dummy
+*.swp
+Gemfile.lock
+.rvmrc
+.DS_Store
+coverage
+.bundle
+.idea
+.ruby-*
+spec/examples.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.simplecov

@@ -0,0 +1,5 @@
+require 'simplecov'
+
+# .simplecov
+SimpleCov.start 'rails' do
+end

data/.travis.yml

@@ -0,0 +1,21 @@
+sudo: false
+cache: bundler
+language: ruby
+rvm:
+  - 2.3.1
+env:
+  matrix:
+    - SOLIDUS_BRANCH=v1.0 DB=postgres
+    - SOLIDUS_BRANCH=v1.1 DB=postgres
+    - SOLIDUS_BRANCH=v1.2 DB=postgres
+    - SOLIDUS_BRANCH=v1.3 DB=postgres
+    - SOLIDUS_BRANCH=v1.4 DB=postgres
+    - SOLIDUS_BRANCH=v2.0 DB=postgres
+    - SOLIDUS_BRANCH=master DB=postgres
+    - SOLIDUS_BRANCH=v1.0 DB=mysql
+    - SOLIDUS_BRANCH=v1.1 DB=mysql
+    - SOLIDUS_BRANCH=v1.2 DB=mysql
+    - SOLIDUS_BRANCH=v1.3 DB=mysql
+    - SOLIDUS_BRANCH=v1.4 DB=mysql
+    - SOLIDUS_BRANCH=v2.0 DB=mysql
+    - SOLIDUS_BRANCH=master DB=mysql

data/Gemfile

@@ -0,0 +1,18 @@
+source "https://rubygems.org"
+
+branch = ENV.fetch('SOLIDUS_BRANCH', 'master')
+gem "solidus", github: "solidusio/solidus", branch: branch
+
+if branch == 'master' || branch >= "v2.0"
+  gem "rails-controller-testing", group: :test
+end
+
+gem 'sqlite3'
+gem 'pg'
+gem 'mysql2'
+
+group :development, :test do
+  gem "pry-rails"
+end
+
+gemspec

data/README.md

@@ -0,0 +1,192 @@
+Active Shipping
+===============
+
+This is a Solidus extension that wraps the popular [active_shipping](http://github.com/Shopify/active_shipping/tree/master) plugin.
+
+**NOTE : This is an old and complex extension we are working on bringing up to our standards. Use with caution**
+
+[![Build Status](https://travis-ci.org/solidusio-contrib/solidus_active_shipping.svg?branch=master)](https://travis-ci.org/solidusio-contrib/solidus_active_shipping)
+
+Installation
+------------
+
+**1.** Add the gem to your application's Gemfile:
+
+To install the latest edge version of this extension, place this line inside your application's Gemfile:
+
+```ruby
+gem 'solidus_active_shipping', :git => "git://github.com/solidusio-contrib/solidus_active_shipping"
+```
+
+**2.** Install migrations and migrate database:
+
+```
+$ bundle exec rake railties:install:migrations
+$ bundle exec rake db:migrate
+```
+
+**3.** Run bundler:
+
+```
+$ bundle
+```
+
+Rate quotes from carriers
+---
+
+So far, this gem supports getting quotes from UPS, USPS, Canada Post, and FedEx. In general, you will need a developer account to get rates. Please contact the shipping vendor that you wish to use about generating a developer account.
+
+Once you have an account, you can go to the active shipping settings admin configuration screen to set the right fields. You need to set all of the Origin Address fields and the fields for the carrier you wish to use. To set the settings through a config file, you can assign values to the settings like so:
+
+```ruby
+Spree::ActiveShipping::Config[:ups_login]
+Spree::ActiveShipping::Config[:ups_password]
+Spree::ActiveShipping::Config[:ups_key]
+Spree::ActiveShipping::Config[:usps_login]
+```
+
+**NOTE:** When setting up FedEx credentials, `:fedex_login` is the "Meter Number" that FedEx supplies you with.
+
+It is important to note how this wrapper matches the calculators to the services available from the carrier API's, by default the base calculator matches the service name to the calculator class and returns the rate, this magic happens as follows:
+
+1. inside the calculator class
+```ruby
+Spree::Calculator::Shipping::Fedex::GroundHomeDelivery::description #holds the service name
+```
+
+2. inside the calculator base
+```ruby
+  rates_result = retrieve_rates_from_cache(package, origin, destination) # <- holds the rates for given package in a parsed hash (see sample response below)
+  rate = rates_result[self.class.description] # <- matches with the description as the key
+```
+
+this means that the calculator **Fedex::GroundHomeDelivery** will hit FedEx Servers and try to get the rates for the given package, since FedEx returns rates for package and returns all of its available services for the given shipment we need to identify which service we are targeting ( see caching results below ) the calculator will only pick the rates from a service that matches the **"FedEx Ground Home Delivery"** string, you can see how it works below:
+
+a sample rate response already parsed looks like this:
+```ruby
+{
+         "FedEx First Overnight" => 5886,
+      "FedEx Priority Overnight" => 2924,
+      "FedEx Standard Overnight" => 2529,
+                "FedEx 2 Day Am" => 1987,
+                   "FedEx 2 Day" => 1774,
+    "FedEx Ground Home Delivery" => 925
+}
+```
+
+the rate hash that is parsed by the calculator has service descriptions as keys, this makes it easier to get the rates you need.
+
+3. getting the rates (all the above together)
+```ruby
+  calculator = Spree::Calculator::Shipping::Fedex::GroundHomeDelivery.new
+  calculator.description # "FedEx Ground Home Delivery"
+  rate = calculator.compute(<Package>)
+  rate # $9.25
+```
+
+you can see the rates are given in cents from FedEx (in the rate hash example above), ```solidus_active_shipping``` converts them dividing them by 100 before sending them to you
+
+**Note:** if you want to integrate to a new carrier service that is not listed below please take care when trying to match the service name key to theirs, there are times when they create dynamic naming conventions, please take as an example **USPS**, you can see the implementation of USPS has the **compute_packages** method overridden to match against a **service_code** key that had to be added to calculator services ( Issue #103 )
+
+Global Handling Fee
+-------------------
+
+```ruby
+Spree::ActiveShipping::Config[:handling_fee]
+```
+
+This property allows you to set a global handling fee that will be added to all calculated shipping rates.  Specify the number of cents, not dollars. You can either set it manually or through the admin interface.
+
+Weights
+---------------------
+
+## Global weight default
+This property allows you to set a default weight that will be substituted for products lacking defined weights. You can either set it manually or through the admin interface.
+
+```ruby
+Spree::ActiveShipping::Config[:default_weight]
+```
+
+## Weight units
+```ruby
+Spree::ActiveShipping::Config[:units]
+```
+
+Product/variant weights in Solidus are not tied to a specific weight system (:imperial or :metric) since the values are only numeric. This value is sent to ActiveShipping so that calculations can be made in the needed weight system. By default this value is set to :imperial but can be switched to :metric.
+
+```ruby
+Spree::ActiveShipping::Config[:unit_multiplier]
+```
+
+ActiveShipping use grams or ounces depending on the weight system specified. If your products weight values are set in a different unit, you can use this parameter to automatically convert them. For example, if your products have their weights in lb, you can set this value to 16 to convert them to oz (as expected by ActiveShipping if using :imperial) since 1 lb = 16 oz.
+
+It is important to note that by default this variable is set to have a value of **16** expecting weights to be entered in **lb**.
+
+For more details on how ActiveShipping use this data, refer to the [active_shipping] (http://github.com/Shopify/active_shipping/tree/master) documentation.
+
+### Example of converting from metric system to oz
+
+Say you have your weights in **kg** you would have to set the multiplier to **0.028**
+
+```ruby
+Spree::ActiveShipping::Config[:unit_multiplier] = 0.0283
+```
+
+## Product packages ##
+
+This extension adds ProductPackages to the Spree::Product. This model can be used to explicitly define how a product is physically shipped.
+For example, you can have a 200lbs product that ships in five smaller 40lbs packages. This allows you to use calculators who would be unavailable otherwise
+because of their weight limits (if a calculator has a max weight of 150lbs, it would not be possible to ship the aforementioned product if we account
+only for total product weight, while the product packages will allow you to ship it since each individual 40lbs product package is under the limit)
+
+Cache
+------------
+
+When Solidus tries to get rates for a given shipment it calls **Spree::Stock::Estimator**, this class is in charge of getting the rates back from any calculator active for a shipment, the way the estimator determines the shipping methods that will apply to the shipment varies from within spree versions but the general idea is this:
+
+**NOTE:** Shipping methods are tied to calculators
+
+```ruby
+  private
+  def shipping_methods(package)
+    shipping_methods = package.shipping_methods
+    shipping_methods.delete_if { |ship_method| !ship_method.calculator.available?(package) }
+    shipping_methods.delete_if { |ship_method| !ship_method.include?(order.ship_address) }
+    shipping_methods.delete_if { |ship_method| !(ship_method.calculator.preferences[:currency].nil? || ship_method.calculator.preferences[:currency] == currency) }
+    shipping_methods
+  end
+```
+
+The money line for **solidus_active_shipping** is when it calls the calculator's ```available?``` method, this method is actually calling the carrier services, and it checks for rates or errors in the form of ```Spree::ShippingError```, if the rates are there for the specified shipment, the calculator will store the parsed rates with a specific key for each package inside the cache, consider the following example to see why this works and why this is necessary:
+
+- User orders N amount of products
+- All of the products from this order are stored in Stock Location 1
+- Once the order creates shipments you will end up with 1 shipment
+- Calculators are active for the following services: **FedEx Ground Home Delivery**, **FedEx 2 Day**, **FedEx International Priority**
+- Order calls the estimator for rates:
+- Estimator will try to get the active shipping methods for this package, it will call available? on all of the active calculators to determine if they are all available for this shipment
+- once it calls it for the first calculator (**FedEx Ground Home Delivery**) it will get the following rates back from FedEx
+
+```ruby
+{
+         "FedEx First Overnight" => 5886,
+      "FedEx Priority Overnight" => 2924,
+      "FedEx Standard Overnight" => 2529,
+                "FedEx 2 Day Am" => 1987,
+                   "FedEx 2 Day" => 1774,
+    "FedEx Ground Home Delivery" => 925
+}
+```
+
+- when it tries to get rates for the 2nd calculator (**FedEx 2 Day**) it will check the cache first and will find that for this package and stock location it already has rates stored in the cache and it won't call FedEx again, using this same rates
+- when it hits the last calculator (**FedEx International Priority**) it will find that the cache doesn't have any rates for the given key, and the method ```available?``` called from the Estimator will return false thus removing the calculator's shipping method from the list of available calculators and won't return any rates back for it
+- Consequently since this 3rd calculator (**FedEx International Priority**) is an international calculator it would have been removed as well by the line that checks if any shipping method is allowed in already defined Zones.
+
+Testing
+-------
+
+Be sure to bundle your dependencies and then create a dummy test app for the specs to run against.
+
+    $ bundle
+    $ bundle exec rake test_app
+    $ bundle exec rspec spec

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir["spec/dummy"].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir("../../")
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'solidus_active_shipping'
+  Rake::Task['extension:test_app'].invoke
+end

data/app/assets/javascripts/admin/product_packages/edit.js.coffee

@@ -0,0 +1,4 @@
+($ '#cancel_link').click (event) ->
+  event.preventDefault()
+
+  ($ '#product_packages').html('')

data/app/assets/javascripts/admin/product_packages/index.js.coffee

@@ -0,0 +1,28 @@
+$ ->
+  ($ '#new_product_package_link').click (event) ->
+    event.preventDefault()
+
+    ($ '.no-objects-found').hide()
+
+    ($ this).hide()
+    $.ajax
+      type: 'GET'
+      url: @href
+      data: (
+        authenticity_token: AUTH_TOKEN
+      )
+      success: (r) ->
+        ($ '#product_packages').html r
+
+  ($ 'a.edit').click (event) ->
+    event.preventDefault()
+
+    ($ '#product_packages').html('')
+    $.ajax
+      type: 'GET'
+      url: @href
+      data: (
+        authenticity_token: AUTH_TOKEN
+      )
+      success: (r) ->
+        ($ '#product_packages').html r

data/app/assets/javascripts/admin/product_packages/new.js.coffee

@@ -0,0 +1,7 @@
+($ '#cancel_link').click (event) ->
+  event.preventDefault()
+
+  ($ '.no-objects-found').show()
+
+  ($ '#new_product_package_link').show()
+  ($ '#product_packages').html('')

data/app/controllers/spree/admin/active_shipping_settings_controller.rb

@@ -0,0 +1,27 @@
+class Spree::Admin::ActiveShippingSettingsController < Spree::Admin::BaseController
+
+  def edit
+    @preferences_UPS = [:ups_login, :ups_password, :ups_key, :shipper_number]
+    @preferences_FedEx = [:fedex_login, :fedex_password, :fedex_account, :fedex_key]
+    @preferences_USPS = [:usps_login]
+    @preferences_CanadaPost = [:canada_post_login]
+    @preferences_GeneralSettings = [:units, :unit_multiplier, :default_weight, :handling_fee, 
+      :max_weight_per_package, :test_mode]
+
+    @config = Spree::ActiveShippingConfiguration.new
+  end
+
+  def update
+    config = Spree::ActiveShippingConfiguration.new
+
+    params.each do |name, value|
+      next unless config.has_preference? name
+      config[name] = value
+    end
+
+    redirect_to edit_admin_active_shipping_settings_path
+  end
+
+end
+
+

data/app/controllers/spree/admin/product_packages_controller.rb

@@ -0,0 +1,17 @@
+module Spree
+  module Admin
+    class ProductPackagesController < ResourceController
+      belongs_to 'spree/product', :find_by => :slug
+      before_filter :load_data
+
+      private
+        def load_data
+          @product = Product.where(:slug => params[:product_id]).first
+        end
+
+        def permitted_product_package_attributes
+          [:length, :width, :height, :weight]
+        end
+    end
+  end
+end

data/app/controllers/spree/admin/products_controller_decorator.rb

@@ -0,0 +1,12 @@
+Spree::Admin::ProductsController.class_eval do
+  def product_packages
+    @product = Spree::Product.find_by_slug!(params[:id])
+    @packages = @product.product_packages
+    @product.product_packages.build
+    
+    respond_with(@object) do |format|
+    format.html { render :layout => !request.xhr? }
+      format.js { render :layout => false }
+    end
+  end
+end

data/app/controllers/spree/checkout_controller_decorator.rb

@@ -0,0 +1,11 @@
+# handle shipping errors gracefully during checkout
+Spree::CheckoutController.class_eval do
+
+  rescue_from Spree::ShippingError, :with => :handle_shipping_error
+
+  private
+    def handle_shipping_error(e)
+      flash[:error] = e.message
+      redirect_to checkout_state_path(:address)
+    end
+end

data/app/controllers/spree/orders_controller_decorator.rb

@@ -0,0 +1,11 @@
+# handle shipping errors gracefully during order update
+Spree::OrdersController.class_eval do
+
+  rescue_from Spree::ShippingError, :with => :handle_shipping_error
+
+  private
+    def handle_shipping_error(e)
+      flash[:error] = e.message
+      redirect_back_or_default(root_path)
+    end
+end

data/app/models/spree/calculator/shipping/active_shipping/base.rb

@@ -0,0 +1,208 @@
+# This is a base calculator for shipping calcualations using the ActiveShipping plugin.  It is not intended to be
+# instantiated directly.  Create subclass for each specific shipping method you wish to support instead.
+#
+# Digest::MD5 is used for cache_key generation.
+require 'digest/md5'
+require_dependency 'spree/calculator'
+
+module Spree
+  module Calculator::Shipping
+    module ActiveShipping
+      class Base < ShippingCalculator
+        def self.service_name
+          description
+        end
+
+        def available?(package)
+          # helps the available? method determine
+          # if rates are avaiable for this service
+          # before calling the carrier for rates
+          is_package_shippable?(package)
+
+          !compute(package).nil?
+        rescue Spree::ShippingError
+          false
+        end
+
+        def compute_package(package)
+          order = package.order
+          max_weight = get_max_weight(package)
+
+          stock_location = package.stock_location
+
+          origin = build_location(stock_location)
+          destination = build_location(order.ship_address)
+
+          rates_result = retrieve_rates_from_cache(package, origin, destination, max_weight)
+
+          return nil if rates_result.is_a?(Spree::ShippingError)
+          return nil if rates_result.empty?
+          rate = rates_result[self.class.description]
+
+          return nil unless rate
+          rate = rate.to_f + (Spree::ActiveShipping::Config[:handling_fee].to_f || 0.0)
+
+          # divide by 100 since active_shipping rates are expressed as cents
+          rate / 100.0
+        end
+
+        def timing(line_items)
+          order = line_items.first.order
+          # TODO: Figure out where stock_location is supposed to come from.
+          origin = ::ActiveShipping::Location.new(country: stock_location.country.iso,
+                                                  city: stock_location.city,
+                                                  state: (stock_location.state ? stock_location.state.abbr : stock_location.state_name),
+                                                  zip: stock_location.zipcode)
+          addr = order.ship_address
+          destination = ::ActiveShipping::Location.new(country: addr.country.iso,
+                                                       state: (addr.state ? addr.state.abbr : addr.state_name),
+                                                       city: addr.city,
+                                                       zip: addr.zipcode)
+          timings_result = Rails.cache.fetch(cache_key(package) + '-timings') do
+            retrieve_timings(origin, destination, packages(order))
+          end
+          raise timings_result if timings_result.is_a?(Spree::ShippingError)
+          return nil if timings_result.nil? || !timings_result.is_a?(Hash) || timings_result.empty?
+          timings_result[description]
+        end
+
+        protected
+
+        # weight limit in ounces or zero (if there is no limit)
+        def max_weight_for_country(_country)
+          0
+        end
+
+        private
+
+        def get_max_weight(solidus_package)
+          order = solidus_package.order
+
+          # Default value from calculator
+          max_weight = max_weight_for_country(order.ship_address.country)
+
+          # If max_weight is zero or max_weight_per_package is less than max_weight
+          # We use the max_weight_per_package instead
+          if max_weight.zero? && max_weight_per_package.nonzero?
+            return max_weight_per_package
+          elsif max_weight > 0 && max_weight_per_package < max_weight && max_weight_per_package > 0
+            return max_weight_per_package
+          end
+
+          max_weight
+        end
+
+        def package_builder
+          @package_builder ||= Spree::PackageBuilder.new
+        end
+
+        def max_weight_per_package
+          Spree::ActiveShipping::Config[:max_weight_per_package] * Spree::ActiveShipping::Config[:unit_multiplier]
+        end
+
+        # check for known limitations inside a package
+        # that will limit you from shipping using a service
+        def is_package_shippable?(package)
+          # check for weight limits on service
+          country_weight_error? package
+        end
+
+        def country_weight_error?(package)
+          max_weight = max_weight_for_country(package.order.ship_address.country)
+          raise Spree::ShippingError, "#{I18n.t(:shipping_error)}: The maximum per package weight for the selected service from the selected country is #{max_weight} ounces." unless valid_weight_for_package?(package, max_weight)
+        end
+
+        # zero weight check means no check
+        # nil check means service isn't available for that country
+        def valid_weight_for_package?(package, max_weight)
+          return false if max_weight.nil?
+          return true if max_weight.zero?
+          package.weight <= max_weight
+        end
+
+        def retrieve_rates(origin, destination, shipment_packages)
+          response = carrier.find_rates(origin, destination, shipment_packages)
+          # turn this beastly array into a nice little hash
+          rates = response.rates.collect do |rate|
+            service_name = rate.service_name.encode('UTF-8')
+            [CGI.unescapeHTML(service_name), rate.price]
+          end
+          rate_hash = Hash[*rates.flatten]
+          return rate_hash
+        rescue ::ActiveShipping::Error => e
+
+          if [::ActiveShipping::ResponseError].include?(e.class) && e.response.is_a?(::ActiveShipping::Response)
+            params = e.response.params
+            if params.key?('Response') && params['Response'].key?('Error') && params['Response']['Error'].key?('ErrorDescription')
+              message = params['Response']['Error']['ErrorDescription']
+            # Canada Post specific error message
+            elsif params.key?('eparcel') && params['eparcel'].key?('error') && params['eparcel']['error'].key?('statusMessage')
+              message = e.response.params['eparcel']['error']['statusMessage']
+            else
+              message = e.message
+            end
+          else
+            message = e.message
+          end
+
+          error = Spree::ShippingError.new("#{I18n.t(:shipping_error)}: #{message}")
+          Rails.cache.write @cache_key, error # write error to cache to prevent constant re-lookups
+          raise error
+        end
+
+        def retrieve_timings(origin, destination, packages)
+          if carrier.respond_to?(:find_time_in_transit)
+            response = carrier.find_time_in_transit(origin, destination, packages)
+            return response
+          end
+        rescue ::ActiveShipping::ResponseError => re
+          if re.response.is_a?(::ActiveShipping::Response)
+            params = re.response.params
+            if params.key?('Response') && params['Response'].key?('Error') && params['Response']['Error'].key?('ErrorDescription')
+              message = params['Response']['Error']['ErrorDescription']
+            else
+              message = re.message
+            end
+          else
+            message = re.message
+          end
+
+          error = Spree::ShippingError.new("#{I18n.t(:shipping_error)}: #{message}")
+          Rails.cache.write @cache_key + '-timings', error # write error to cache to prevent constant re-lookups
+          raise error
+        end
+
+        def cache_key(package)
+          stock_location = package.stock_location.nil? ? '' : "#{package.stock_location.id}-"
+          order = package.order
+          ship_address = package.order.ship_address
+          contents_hash = Digest::MD5.hexdigest(package.contents.map { |content_item| content_item.variant.id.to_s + '_' + content_item.quantity.to_s }.join('|'))
+          @cache_key = "#{stock_location}#{carrier.name}-#{order.number}-#{ship_address.country.iso}-#{fetch_best_state_from_address(ship_address)}-#{ship_address.city}-#{ship_address.zipcode}-#{contents_hash}-#{I18n.locale}".delete(' ')
+        end
+
+        def fetch_best_state_from_address(address)
+          address.state ? address.state.abbr : address.state_name
+        end
+
+        def build_location(address)
+          ::ActiveShipping::Location.new(country: address.country.iso,
+                                         state: fetch_best_state_from_address(address),
+                                         city: address.city,
+                                         zip: address.zipcode)
+        end
+
+        def retrieve_rates_from_cache(package, origin, destination, max_weight)
+          Rails.cache.fetch(cache_key(package)) do
+            shipment_packages = package_builder.process(package, max_weight)
+            # shipment_packages = packages(package)
+            if shipment_packages.empty?
+              {}
+            else
+              retrieve_rates(origin, destination, shipment_packages)
+            end
+          end
+        end
+      end
+    end
+  end
+end