solidus_shipstation 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'solidus_dev_support/rake_tasks'
+SolidusDevSupport::RakeTasks.install
+
+task default: 'extension:specs'

data/app/assets/javascripts/spree/backend/solidus_shipstation.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/backend/all.js'

data/app/assets/javascripts/spree/frontend/solidus_shipstation.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/frontend/all.js'

data/app/assets/stylesheets/spree/backend/solidus_shipstation.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/

data/app/assets/stylesheets/spree/frontend/solidus_shipstation.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/frontend/all.css'
+*/

data/app/controllers/spree/shipstation_controller.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Spree
+  class ShipstationController < Spree::BaseController
+    protect_from_forgery with: :null_session, only: :shipnotify
+
+    before_action :authenticate_shipstation
+
+    def export
+      @shipments = SolidusShipstation::Shipment::ExportableQuery.apply(Spree::Shipment.all)
+      @shipments = SolidusShipstation::Shipment::BetweenQuery.apply(
+        @shipments,
+        from: date_param(:start_date),
+        to: date_param(:end_date),
+      )
+      @shipments = @shipments.page(params[:page]).per(50)
+
+      respond_to do |format|
+        format.xml { render layout: false }
+      end
+    end
+
+    def shipnotify
+      SolidusShipstation::ShipmentNotice.from_payload(params.to_unsafe_h).apply
+      head :ok
+    rescue SolidusShipstation::Error => e
+      head :bad_request
+    end
+
+    private
+
+    def date_param(name)
+      return if params[name].blank?
+
+      Time.strptime("#{params[name]} UTC", '%m/%d/%Y %H:%M %Z')
+    end
+
+    def authenticate_shipstation
+      authenticate_or_request_with_http_basic do |username, password|
+        username == SolidusShipstation.configuration.username &&
+          password == SolidusShipstation.configuration.password
+      end
+    end
+  end
+end

data/app/decorators/models/solidus_shipstation/spree/shipment_decorator.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Spree
+    module ShipmentDecorator
+      def self.prepended(base)
+        base.singleton_class.prepend ClassMethods
+      end
+
+      module ClassMethods
+        def exportable
+          ::Spree::Deprecation.warn <<~DEPRECATION
+            `Spree::Shipment.exportable` is deprecated and will be removed in a future version
+            of solidus_shipstation. Please use `SolidusShipstation::Shipment::ExportableQuery.apply`.
+          DEPRECATION
+
+          SolidusShipstation::Shipment::ExportableQuery.apply(self)
+        end
+
+        def between(from, to)
+          ::Spree::Deprecation.warn <<~DEPRECATION
+            `Spree::Shipment.between` is deprecated and will be removed in a future version
+            of solidus_shipstation. Please use `SolidusShipstation::Shipment::BetweenQuery.apply`.
+          DEPRECATION
+
+          SolidusShipstation::Shipment::BetweenQuery.apply(self, from: from, to: to)
+        end
+      end
+
+      ::Spree::Shipment.prepend self
+    end
+  end
+end

data/app/helpers/solidus_shipstation/export_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'builder'
+
+module SolidusShipstation
+  module ExportHelper
+    DATE_FORMAT = '%m/%d/%Y %H:%M'
+
+    # rubocop:disable all
+    def self.address(xml, order, type)
+      name = "#{type.to_s.titleize}To"
+      address = order.send("#{type}_address")
+
+      xml.__send__(name) {
+        xml.Name         address.respond_to?(:name) ? address.name : address.full_name
+        xml.Company      address.company
+
+        if type == :ship
+          xml.Address1   address.address1
+          xml.Address2   address.address2
+          xml.City       address.city
+          xml.State      address.state ? address.state.abbr : address.state_name
+          xml.PostalCode address.zipcode
+          xml.Country    address.country.iso
+        end
+
+        xml.Phone        address.phone
+      }
+    end
+    # rubocop:enable all
+  end
+end

data/app/jobs/solidus_shipstation/api/schedule_shipment_syncs_job.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Api
+    class ScheduleShipmentSyncsJob < ApplicationJob
+      queue_as :default
+
+      def perform
+        shipments = SolidusShipstation::Shipment::PendingApiSyncQuery.apply(::Spree::Shipment.all)
+
+        shipments.find_in_batches(batch_size: SolidusShipstation.config.api_batch_size) do |batch|
+          SyncShipmentsJob.perform_later(batch.to_a)
+        end
+      rescue StandardError => e
+        SolidusShipstation.config.error_handler.call(e, {})
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  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
+        SolidusShipstation.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_shipstation.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_shipstation/shipment/between_query.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  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_shipstation/shipment/exportable_query.rb

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

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SolidusShipstation
+  module Shipment
+    class PendingApiSyncQuery
+      SQLITE_CONDITION = <<~SQL.squish
+        (
+          spree_shipments.shipstation_synced_at IS NULL
+          OR (
+            spree_shipments.shipstation_synced_at IS NOT NULL
+              AND spree_shipments.shipstation_synced_at < spree_orders.updated_at
+          )
+        ) AND ((JULIANDAY(CURRENT_TIMESTAMP) - JULIANDAY(spree_orders.updated_at)) * 86400.0) < :threshold
+      SQL
+
+      POSTGRES_CONDITION = <<~SQL.squish
+        (
+          spree_shipments.shipstation_synced_at IS NULL
+          OR (
+            spree_shipments.shipstation_synced_at IS NOT NULL
+              AND spree_shipments.shipstation_synced_at < spree_orders.updated_at
+          )
+        ) AND (EXTRACT(EPOCH FROM (CURRENT_TIMESTAMP - spree_orders.updated_at))) < :threshold
+      SQL
+
+      MYSQL2_CONDITION = <<~SQL.squish
+        (
+          spree_shipments.shipstation_synced_at IS NULL
+            OR (
+              spree_shipments.shipstation_synced_at IS NOT NULL
+                AND spree_shipments.shipstation_synced_at < spree_orders.updated_at
+          )
+        ) 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: SolidusShipstation.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 "ShipStation API sync not supported for DB adapter #{db_adapter}!"
+          end
+        end
+      end
+    end
+  end
+end

data/app/views/spree/shipstation/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(SolidusShipstation::ExportHelper::DATE_FORMAT)
+      xml.OrderStatus    shipment.state
+      xml.LastModified   [order.completed_at, shipment.updated_at].max.strftime(SolidusShipstation::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)
+        SolidusShipstation::ExportHelper.address(xml, order, :bill)
+        SolidusShipstation::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 SolidusShipstation.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_shipstation"
+
+# 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_shipstation/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_shipstation"
+
+# 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."