solidus_shipstation 1.0.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+gem install bundler --conservative
+bundle update
+bin/rake clobber

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+---
+en:
+  shipment_not_found: Shipment %{number} was not found
+  import_tracking_error: "Tracking number cannot be imported. Error: %{error}"
+  capture_payment_error: "Error in capture of payment for order %{number}. Error: %{error}"

data/config/routes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+Spree::Core::Engine.routes.draw do
+  get '/shipstation', to: 'shipstation#export'
+  post '/shipstation', to: 'shipstation#shipnotify'
+end

data/db/migrate/20210220093010_add_shipstation_api_sync_fields.rb

@@ -0,0 +1,9 @@
+# NOTE: This migration is only required if you use the API integration strategy.
+# If you're using the XML file instead, you can safely skip these columns.
+
+class AddShipstationApiSyncFields < ActiveRecord::Migration[5.2]
+  def change
+    add_column :spree_shipments, :shipstation_synced_at, :datetime
+    add_column :spree_shipments, :shipstation_order_id, :string
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      class_option :auto_run_migrations, type: :boolean, default: false
+      source_root File.expand_path('templates', __dir__)
+
+      def copy_initializer
+        template 'initializer.rb', 'config/initializers/solidus_shipstation.rb'
+      end
+
+      def add_migrations
+        run 'bin/rails railties:install:migrations FROM=solidus_shipstation'
+      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 'bin/rails db:migrate'
+        else
+          puts 'Skipping bin/rails db:migrate, don\'t forget to run it!' # rubocop:disable Rails/Output
+        end
+      end
+    end
+  end
+end

data/lib/generators/solidus_shipstation/install/templates/initializer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+SolidusShipstation.configure do |config|
+  # Choose between Grams, Ounces or Pounds.
+  config.weight_units = "Grams"
+
+  # Capture payment when ShipStation notifies a shipping label creation.
+  # Set this to `true` and `Spree::Config.require_payment_to_ship` to `false` if you
+  # want to charge your customers at the time of shipment.
+  config.capture_at_notification = false
+
+  # ShipStation expects the endpoint to be protected by HTTP Basic Auth.
+  # Set the username and password you desire for ShipStation to use.
+  config.username = "smoking_jay_cutler"
+  config.password = "my-awesome-password"
+
+  ####### XML integration
+  # Only uncomment these lines if you're going to use the XML integration.
+
+  # Export canceled shipments to ShipStation
+  # Set this to `true` if you want canceled shipments included in the endpoint.
+  # config.export_canceled_shipments = false
+
+  ####### API integration
+  # Only uncomment these lines if you're going to use the API integration.
+
+  # Override the shipment serializer used for API sync. This can be any object
+  # that responds to `#call`. At the very least, you'll need to uncomment the
+  # following lines and customize your store ID.
+  # config.api_shipment_serializer = proc do |shipment|
+  #   SolidusShipstation::Api::ShipmentSerializer.new(store_id: '12345678').call(shipment)
+  # end
+
+  # Override the logic used to match a ShipStation order to a shipment from a
+  # given collection. This can be useful when you override the default serializer
+  # and change the logic used to generate the order number.
+  # config.api_shipment_matcher = proc do |shipstation_order, shipments|
+  #   shipments.find { |shipment| shipment.number == shipstation_order['orderNumber'] }
+  # end
+
+  # API key and secret for accessing the ShipStation API.
+  # config.api_key = "api-key"
+  # config.api_secret = "api-secret"
+
+  # Number of shipments to import into ShipStation at once.
+  # If unsure, leave this set to 100, which is the maximum
+  # number of shipments that can be imported at once.
+  # config.api_batch_size = 100
+
+  # Period of time after which the integration will "drop" shipments and stop
+  # trying to create/update them. This prevents the API from retrying indefinitely
+  # in case an error prevents some shipments from being created/updated.
+  # config.api_sync_threshold = 7.days
+
+  # Error handler used by the API integration for certain non-critical errors (e.g.
+  # a failure when serializing a shipment from a batch). This should be a proc that
+  # accepts an exception and a context hash. Popular options for error handling are
+  # logging or sending the error to an error tracking tool such as Sentry.
+  # config.error_handler = -> (error, context = {}) {
+  #   Sentry.capture_exception(error, extra: context)
+  # }
+end

data/lib/solidus_shipstation.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+require 'solidus_shipstation/api/batch_syncer'
+require 'solidus_shipstation/api/request_runner'
+require 'solidus_shipstation/api/client'
+require 'solidus_shipstation/api/request_error'
+require 'solidus_shipstation/api/rate_limited_error'
+require 'solidus_shipstation/api/shipment_serializer'
+require 'solidus_shipstation/api/threshold_verifier'
+require 'solidus_shipstation/configuration'
+require 'solidus_shipstation/errors'
+require 'solidus_shipstation/shipment_notice'
+require 'solidus_shipstation/version'
+require 'solidus_shipstation/engine'

data/lib/solidus_shipstation/api/batch_syncer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Api
+    class BatchSyncer
+      class << self
+        def from_config
+          new(
+            client: SolidusShipstation::Api::Client.from_config,
+            shipment_matcher: SolidusShipstation.config.api_shipment_matcher,
+          )
+        end
+      end
+
+      attr_reader :client, :shipment_matcher
+
+      def initialize(client:, shipment_matcher:)
+        @client = client
+        @shipment_matcher = shipment_matcher
+      end
+
+      def call(shipments)
+        begin
+          response = client.bulk_create_orders(shipments)
+        rescue RateLimitedError => e
+          ::Spree::Event.fire(
+            'solidus_shipstation.api.rate_limited',
+            shipments: shipments,
+            error: e,
+          )
+
+          raise e
+        rescue RequestError => e
+          ::Spree::Event.fire(
+            'solidus_shipstation.api.sync_errored',
+            shipments: shipments,
+            error: e,
+          )
+
+          raise e
+        end
+
+        response['results'].each do |shipstation_order|
+          shipment = shipment_matcher.call(shipstation_order, shipments)
+
+          unless shipstation_order['success']
+            ::Spree::Event.fire(
+              'solidus_shipstation.api.sync_failed',
+              shipment: shipment,
+              payload: shipstation_order,
+            )
+
+            next
+          end
+
+          shipment.update_columns(
+            shipstation_synced_at: Time.zone.now,
+            shipstation_order_id: shipstation_order['orderId'],
+          )
+
+          ::Spree::Event.fire(
+            'solidus_shipstation.api.sync_completed',
+            shipment: shipment,
+            payload: shipstation_order,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solidus_shipstation/api/client.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Api
+    class Client
+      class << self
+        def from_config
+          new(
+            request_runner: RequestRunner.from_config,
+            error_handler: SolidusShipstation.config.error_handler,
+            shipment_serializer: SolidusShipstation.config.api_shipment_serializer,
+          )
+        end
+      end
+
+      attr_reader :request_runner, :error_handler, :shipment_serializer
+
+      def initialize(request_runner:, error_handler:, shipment_serializer:)
+        @request_runner = request_runner
+        @error_handler = error_handler
+        @shipment_serializer = shipment_serializer
+      end
+
+      def bulk_create_orders(shipments)
+        params = shipments.map do |shipment|
+          shipment_serializer.call(shipment)
+        rescue StandardError => e
+          error_handler.call(e, shipment: shipment)
+          nil
+        end.compact
+
+        return if params.empty?
+
+        request_runner.call(:post, '/orders/createorders', params)
+      end
+    end
+  end
+end

data/lib/solidus_shipstation/api/rate_limited_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Api
+    class RateLimitedError < RequestError
+      attr_reader :retry_in
+
+      class << self
+        def options_from_response(response)
+          super.merge(
+            retry_in: response.headers['X-Rate-Limit-Reset'].to_i.seconds,
+          )
+        end
+      end
+
+      def initialize(retry_in:, **options)
+        super(**options)
+
+        @retry_in = retry_in
+      end
+    end
+  end
+end

data/lib/solidus_shipstation/api/request_error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Api
+    class RequestError < RuntimeError
+      attr_reader :response_code, :response_body, :response_headers
+
+      class << self
+        def from_response(response)
+          new(**options_from_response(response))
+        end
+
+        private
+
+        def options_from_response(response)
+          {
+            response_code: response.code,
+            response_headers: response.headers,
+            response_body: response.body,
+          }
+        end
+      end
+
+      def initialize(response_code:, response_body:, response_headers:)
+        @response_code = response_code
+        @response_body = response_body
+        @response_headers = response_headers
+
+        super(response_body)
+      end
+    end
+  end
+end

data/lib/solidus_shipstation/api/request_runner.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Api
+    class RequestRunner
+      API_BASE = 'https://ssapi.shipstation.com'
+
+      attr_reader :username, :password
+
+      class << self
+        def from_config
+          new(
+            username: SolidusShipstation.config.api_key,
+            password: SolidusShipstation.config.api_secret,
+          )
+        end
+      end
+
+      def initialize(username:, password:)
+        @username = username
+        @password = password
+      end
+
+      def call(method, path, params = {})
+        response = HTTParty.send(
+          method,
+          URI.join(API_BASE, path),
+          body: params.to_json,
+          basic_auth: {
+            username: @username,
+            password: @password,
+          },
+          headers: {
+            'Content-Type' => 'application/json',
+            'Accept' => 'application/json',
+          },
+        )
+
+        case response.code.to_s
+        when /2\d{2}/
+          response.parsed_response
+        when '429'
+          raise RateLimitedError.from_response(response)
+        else
+          raise RequestError.from_response(response)
+        end
+      end
+    end
+  end
+end

data/lib/solidus_shipstation/api/shipment_serializer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Api
+    class ShipmentSerializer
+      attr_reader :store_id
+
+      def initialize(store_id:)
+        @store_id = store_id
+      end
+
+      def call(shipment)
+        order = shipment.order
+
+        state = case shipment.state
+                when 'ready'
+                  'awaiting_shipment'
+                when 'shipped'
+                  'shipped'
+                when 'pending'
+                  if ::Spree::Config.require_payment_to_ship && !shipment.order.paid?
+                    'awaiting_payment'
+                  else
+                    'on_hold'
+                  end
+                when 'canceled'
+                  'cancelled'
+                end
+
+        {
+          orderNumber: shipment.number,
+          orderKey: shipment.number,
+          orderDate: order.completed_at.iso8601,
+          paymentDate: order.payments.find(&:valid?)&.created_at&.iso8601,
+          orderStatus: state,
+          customerId: order.user&.id,
+          customerUsername: order.email,
+          customerEmail: order.email,
+          billTo: serialize_address(order.bill_address),
+          shipTo: serialize_address(order.ship_address),
+          items: shipment.line_items.map(&method(:serialize_line_item)),
+          shippingAmount: shipment.cost,
+          paymentMethod: 'Credit Card',
+          advancedOptions: {
+            storeId: store_id,
+          },
+        }
+      end
+
+      private
+
+      def serialize_address(address)
+        {
+          name: SolidusSupport.combined_first_and_last_name_in_address? ? address.name : address.full_name,
+          company: address.company,
+          street1: address.address1,
+          street2: address.address2,
+          city: address.city,
+          state: address.state&.abbr,
+          postalCode: address.zipcode,
+          country: address.country&.iso,
+          phone: address.phone,
+        }
+      end
+
+      def serialize_line_item(line_item)
+        {
+          lineItemKey: "LineItem/#{line_item.id}",
+          sku: line_item.sku,
+          name: line_item.variant.descriptive_name,
+          imageUrl: line_item.variant.images.first.try(:attachment).try(:url),
+          quantity: line_item.quantity,
+          unitPrice: line_item.price,
+          taxAmount: line_item.additional_tax_total,
+          adjustment: false,
+          weight: {
+            value: line_item.variant.weight.to_f,
+            units: SolidusShipstation.config.weight_units,
+          },
+        }
+      end
+    end
+  end
+end