solidus_backtracs 2.2.0

data/app/jobs/solidus_backtracs/api/sync_shipments_job.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Api
+    class SyncShipmentsJob < ApplicationJob
+      queue_as :default
+
+      def perform(shipments)
+        shipments = select_shipments(shipments)
+        return if shipments.empty?
+
+        sync_shipments(shipments)
+      rescue RateLimitedError => e
+        self.class.set(wait: e.retry_in).perform_later
+      rescue StandardError => e
+        SolidusBacktracs.config.error_handler.call(e, {})
+      end
+
+      private
+
+      def select_shipments(shipments)
+        shipments.select do |shipment|
+          if ThresholdVerifier.call(shipment)
+            true
+          else
+            ::Spree::Event.fire(
+              'solidus_backtracs.api.sync_skipped',
+              shipment: shipment,
+            )
+
+            false
+          end
+        end
+      end
+
+      def sync_shipments(shipments)
+        BatchSyncer.from_config.call(shipments)
+      end
+    end
+  end
+end

data/app/queries/solidus_backtracs/shipment/between_query.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Shipment
+    class BetweenQuery
+      def self.apply(scope, from:, to:)
+        scope.joins(:order).where(<<~SQL.squish, from: from, to: to)
+          (spree_shipments.updated_at > :from AND spree_shipments.updated_at < :to) OR
+          (spree_orders.updated_at > :from AND spree_orders.updated_at < :to)
+        SQL
+      end
+    end
+  end
+end

data/app/queries/solidus_backtracs/shipment/exportable_query.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Shipment
+    class ExportableQuery
+      def self.apply(scope)
+        scope = scope
+                .order(:updated_at)
+                .joins(:order)
+                .merge(::Spree::Order.complete)
+
+        unless SolidusBacktracs.configuration.capture_at_notification
+          scope = scope.where(spree_shipments: { state: ['ready', 'canceled'] })
+        end
+
+        unless SolidusBacktracs.configuration.export_canceled_shipments
+          scope = scope.where.not(spree_shipments: { state: 'canceled' })
+        end
+
+        scope
+      end
+    end
+  end
+end

data/app/queries/solidus_backtracs/shipment/pending_api_sync_query.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Shipment
+    class PendingApiSyncQuery
+      SQLITE_CONDITION = <<~SQL.squish
+        (
+          spree_shipments.backtracs_synced_at IS NULL
+        ) AND ((JULIANDAY(CURRENT_TIMESTAMP) - JULIANDAY(spree_orders.updated_at)) * 86400.0) < :threshold
+      SQL
+
+      POSTGRES_CONDITION = <<~SQL.squish
+        (
+          spree_shipments.backtracs_synced_at IS NULL
+        ) AND (EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - spree_orders.updated_at))) < :threshold
+      SQL
+
+      MYSQL2_CONDITION = <<~SQL.squish
+        (
+          spree_shipments.backtracs_synced_at IS NULL
+        ) AND (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(spree_orders.updated_at)) < :threshold
+      SQL
+
+      class << self
+        def apply(scope)
+          scope
+            .joins(:order)
+            .merge(::Spree::Order.complete)
+            .where(condition_for_adapter, threshold: SolidusBacktracs.config.api_sync_threshold / 1.second)
+        end
+
+        private
+
+        def condition_for_adapter
+          db_adapter = ActiveRecord::Base.connection.adapter_name.downcase
+
+          case db_adapter
+          when /sqlite/
+            SQLITE_CONDITION
+          when /postgres/
+            POSTGRES_CONDITION
+          when /mysql2/
+            MYSQL2_CONDITION
+          else
+            fail "Backtracs API sync not supported for DB adapter #{db_adapter}!"
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/spree/backtracs/export.xml.builder

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+xml = Builder::XmlMarkup.new
+xml.instruct!
+xml.Orders(pages: (@shipments.total_count / 50.0).ceil) {
+  @shipments.each do |shipment|
+    order = shipment.order
+
+    xml.Order {
+      xml.OrderID        shipment.id
+      xml.OrderNumber    shipment.number # do not use shipment.order.number as this presents lookup issues
+      xml.OrderDate      order.completed_at.strftime(SolidusBacktracs::ExportHelper::DATE_FORMAT)
+      xml.OrderStatus    shipment.state
+      xml.LastModified   [order.completed_at, shipment.updated_at].max.strftime(SolidusBacktracs::ExportHelper::DATE_FORMAT)
+      xml.ShippingMethod shipment.shipping_method.try(:name)
+      xml.OrderTotal     order.total
+      xml.TaxAmount      order.tax_total
+      xml.ShippingAmount order.ship_total
+      xml.CustomField1   order.number
+
+      #       if order.gift?
+      #         xml.Gift
+      #         xml.GiftMessage
+      #       end
+
+      xml.Customer {
+        xml.CustomerCode order.email.slice(0, 50)
+        SolidusBacktracs::ExportHelper.address(xml, order, :bill)
+        SolidusBacktracs::ExportHelper.address(xml, order, :ship)
+      }
+      xml.Items {
+        shipment.line_items.each do |line|
+          variant = line.variant
+          xml.Item {
+            xml.SKU         variant.sku
+            xml.Name        [variant.product.name, variant.options_text].join(' ')
+            xml.ImageUrl    variant.images.first.try(:attachment).try(:url)
+            xml.Weight      variant.weight.to_f
+            xml.WeightUnits SolidusBacktracs.configuration.weight_units
+            xml.Quantity    line.quantity
+            xml.UnitPrice   line.price
+
+            if variant.option_values.present?
+              xml.Options {
+                variant.option_values.each do |value|
+                  xml.Option {
+                    xml.Name  value.option_type.presentation
+                    xml.Value value.name
+                  }
+                end
+              }
+            end
+          }
+        end
+      }
+    }
+  end
+}

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "solidus_backtracs"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+$LOAD_PATH.unshift(*Dir["#{__dir__}/../app/*"])
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/rails

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+if %w[g generate].include? ARGV.first
+  exec "#{__dir__}/rails-engine", *ARGV
+else
+  exec "#{__dir__}/rails-sandbox", *ARGV
+end

data/bin/rails-engine

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/solidus_backtracs/engine', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/rails-sandbox

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+app_root = 'sandbox'
+
+unless File.exist? "#{app_root}/bin/rails"
+  warn 'Creating the sandbox app...'
+  Dir.chdir "#{__dir__}/.." do
+    system "#{__dir__}/sandbox" or begin
+      warn 'Automatic creation of the sandbox app failed'
+      exit 1
+    end
+  end
+end
+
+Dir.chdir app_root
+exec 'bin/rails', *ARGV

data/bin/rake

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/sandbox

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+
+set -e
+
+case "$DB" in
+postgres|postgresql)
+  RAILSDB="postgresql"
+  ;;
+mysql)
+  RAILSDB="mysql"
+  ;;
+sqlite|'')
+  RAILSDB="sqlite3"
+  ;;
+*)
+  echo "Invalid DB specified: $DB"
+  exit 1
+  ;;
+esac
+
+if [ ! -z $SOLIDUS_BRANCH ]
+then
+  BRANCH=$SOLIDUS_BRANCH
+else
+  BRANCH="master"
+fi
+
+extension_name="solidus_backtracs"
+
+# Stay away from the bundler env of the containing extension.
+function unbundled {
+  ruby -rbundler -e'b = proc {system *ARGV}; Bundler.respond_to?(:with_unbundled_env) ? Bundler.with_unbundled_env(&b) : Bundler.with_clean_env(&b)' -- $@
+}
+
+rm -rf ./sandbox
+unbundled bundle exec rails new sandbox --database="$RAILSDB" \
+  --skip-bundle \
+  --skip-git \
+  --skip-keeps \
+  --skip-rc \
+  --skip-spring \
+  --skip-test \
+  --skip-javascript
+
+if [ ! -d "sandbox" ]; then
+  echo 'sandbox rails application failed'
+  exit 1
+fi
+
+cd ./sandbox
+cat <<RUBY >> Gemfile
+gem 'solidus', github: 'solidusio/solidus', branch: '$BRANCH'
+gem 'solidus_auth_devise', '>= 2.1.0'
+gem 'rails-i18n'
+gem 'solidus_i18n'
+
+gem '$extension_name', path: '..'
+
+group :test, :development do
+  platforms :mri do
+    gem 'pry-byebug'
+  end
+end
+RUBY
+
+unbundled bundle install --gemfile Gemfile
+
+unbundled bundle exec rake db:drop db:create
+
+unbundled bundle exec rails generate solidus:install \
+  --auto-accept \
+  --user_class=Spree::User \
+  --enforce_available_locales=true \
+  --with-authentication=false \
+  --payment-method=none \
+  $@
+
+unbundled bundle exec rails generate solidus:auth:install
+unbundled bundle exec rails generate ${extension_name}:install
+
+echo
+echo "🚀 Sandbox app successfully created for $extension_name!"
+echo "🚀 Using $RAILSDB and Solidus $BRANCH"
+echo "🚀 Use 'export DB=[postgres|mysql|sqlite]' to control the DB adapter"
+echo "🚀 Use 'export SOLIDUS_BRANCH=<BRANCH-NAME>' to control the Solidus version"
+echo "🚀 This app is intended for test purposes."

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 '/backtracs', to: 'backtracs#export'
+  # post '/backtracs', to: 'backtracs#shipnotify'
+end

data/db/migrate/20210220093010_add_backtracs_api_sync_fields.rb

@@ -0,0 +1,8 @@
+# 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 AddBacktracsApiSyncFields < ActiveRecord::Migration[5.2]
+  def change
+    add_column :spree_shipments, :backtracs_synced_at, :datetime
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  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_backtracs.rb'
+      end
+
+      def add_migrations
+        run 'bin/rails railties:install:migrations FROM=solidus_backtracs'
+      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_backtracs/install/templates/initializer.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+SolidusBacktracs.configure do |config|
+  # Choose between Grams, Ounces or Pounds.
+  config.weight_units = "Grams"
+
+  # Capture payment when Backtracs 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
+
+  ## API Configuration
+  config.api_base = ENV['BACKTRACS_API_BASE'] || 'https://bactracstest.andlor.com'
+
+  # Backtracs expects the endpoint to be protected by HTTP Basic Auth.
+  # Set the username and password you desire for Backtracs to use.
+  config.webhook_username = "smoking_jay_cutler"
+  config.webhook_password = "my-awesome-password"
+
+  ## Proxy
+  config.proxy_address = ENV['PROXY_ADDRESS']
+  config.proxy_port = ENV['PROXY_PORT']
+  config.proxy_username = ENV['PROXY_USER']
+  config.proxy_password = ENV['PROXY_PASS']
+
+  ## Authentication Service Credentials
+  config.authentication_username = "red_blue_jay"
+  config.authentication_password = "my-secret-other-password"
+
+
+  ## Shipment Serializer Configuration
+  config.sku_map = {}
+  config.default_rma_type = "W"
+  config.default_carrier = "FedExGrnd"
+  config.default_ship_method = "GROUND"  
+  config.default_status = "OPEN"
+  config.default_rp_location = "FG-NEW"
+  config.shippable_skus = []
+  config.default_property_name = "XYZ"
+
+  ####### XML integration
+  # Only uncomment these lines if you're going to use the XML integration.
+
+  # Export canceled shipments to Backtracs
+  # Set this to `true` if you want canceled shipments included in the endpoint.
+  # config.export_canceled_shipments = false
+
+  # You can customize the class used to receive notifications from the POST request
+  # Make sure it has a class method `from_payload` which receives the notification hash
+  # and an instance method `apply`
+  # config.shipment_notice_class = 'SolidusBacktracs::ShipmentNotice'
+
+  ####### 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|
+  #   SolidusBacktracs::Api::ShipmentSerializer.new(store_id: '12345678').call(shipment)
+  # end
+
+  # Override the logic used to match a Backtracs 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 |backtracs_order, shipments|
+  #   shipments.find { |shipment| shipment.number == backtracs_order['orderNumber'] }
+  # end
+
+  # API key and secret for accessing the Backtracs API.
+  # config.api_key = "api-key"
+  # config.api_secret = "api-secret"
+
+  # Number of shipments to import into Backtracs 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_backtracs/api/batch_syncer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Api
+    class BatchSyncer
+      class << self
+        def from_config
+          new(
+            client: SolidusBacktracs::Api::Client.from_config,
+            shipment_matcher: SolidusBacktracs.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_backtracs.api.rate_limited',
+            shipments: shipments,
+            error: e,
+          )
+
+          raise e
+        rescue RequestError => e
+          ::Spree::Event.fire(
+            'solidus_backtracs.api.sync_errored',
+            shipments: shipments,
+            error: e,
+          )
+
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/solidus_backtracs/api/client.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Api
+    class Client
+      class << self
+        def from_config
+          new(
+            request_runner: RequestRunner.new,
+            error_handler: SolidusBacktracs.config.error_handler,
+            shipment_serializer: SolidusBacktracs.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)
+        shipments.each do |shipment|
+          SolidusBacktracs::Api::SyncShipmentJob.perform_now(
+            shipment_id: shipment.id,
+            error_handler: @error_handler,
+            shipment_serializer: @shipment_serializer,
+            request_runner: @request_runner
+          )
+        end.compact
+      end
+    end
+  end
+end

data/lib/solidus_backtracs/api/rate_limited_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  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_backtracs/api/request_error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  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