solidus_bactracs 3.0.0

data/lib/solidus_backtracs/api/request_runner.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+require "uri"
+require "net/http"
+
+module SolidusBacktracs
+  module Api
+    class RequestRunner
+
+      def initialize
+        @username = SolidusBacktracs.configuration.authentication_username
+        @password = SolidusBacktracs.configuration.authentication_password
+        @api_base = SolidusBacktracs.configuration.api_base
+        @retries  = SolidusBacktracs.configuration.api_retries
+      end
+
+      def authenticated_call(method: nil, path: nil, serializer: nil, shipment: nil, count: 0)
+        if count <= @retries
+          unless @username.present? || @password.present? || @api_base.present?
+            raise "Credentials not defined for Authentication"
+          end
+
+          @response = Rails.cache.fetch("backtracks_cache_key", expires_in: 1.hour, skip_nil: true) do
+            self.call(method: :get, path: "/webservices/user/Authentication.asmx/Login?sUserName=#{@username}&sPassword=#{@password}")
+          end
+
+          raise RequestError.from_response(@response) unless @response # just try again for @retries?
+          authenticted = parse_authentication_response(@response, "Result")
+          raise RequestError.from_response(@response) if authenticted == "false"
+          sguid = parse_authentication_response(@response, "Message")
+
+          if authenticted == 'false'
+            clear_cache
+            raise "User Not Authenticated"
+          else
+            sguid = parse_authentication_response(@response, "Message")
+            params = serializer.call(shipment, sguid)
+
+            rma_response = call(method: :post, path: path, params: params)
+            unless parse_rma_creation_response(rma_response) == 'true'
+              clear_cache
+              count += 1
+              self.authenticated_call(method: :post, path: '/webservices/rma/rmaservice.asmx', serializer: serializer, shipment: shipment, count: count)
+            end
+            shipment_synced(shipment)
+          end
+        else
+          shipment_sync_failed(shipment)
+        end
+      end
+
+      def call(method: nil, path: nil, params: {})
+        doc = {}
+        if params.present?
+          doc = Nokogiri::XML(params.to_s)
+        end
+        response = HTTParty.send(
+          method,
+          URI.join(@api_base, path),
+          body: doc.to_xml,
+          http_proxyaddr: SolidusBacktracs.configuration.proxy_address,
+          http_proxyport: SolidusBacktracs.configuration.proxy_port,
+          http_proxyuser: SolidusBacktracs.configuration.proxy_username,
+          http_proxypass: SolidusBacktracs.configuration.proxy_password,
+          headers: {
+            'Content-Type' => 'text/xml',
+          },
+        )
+
+        case response.code.to_s
+        when /2\d{2}/
+          response
+        when '429'
+          raise RateLimitedError.from_response(response)
+        else
+          raise RequestError.from_response(response)
+        end
+      end
+
+      def clear_cache
+        Rails.cache.delete('backtracks_cache_key')
+        @response = nil
+      end
+
+      def parse_authentication_response(response, type)
+        response.dig("AuthenticationResponse", type)
+      end
+
+      def parse_rma_creation_response(response)
+        response.dig("Envelope", "Body", "CreateNewResponse", "CreateNewResult", "Result")
+      end
+
+      def shipment_synced(shipment)
+        shipment.update_column(:backtracs_synced_at, Time.zone.now)
+
+        ::Spree::Event.fire(
+          'solidus_backtracs.api.sync_completed',
+          shipment: shipment
+        )
+      end
+
+      def shipment_sync_failed(shipment)
+        ::Spree::Event.fire(
+          'solidus_backtracs.api.sync_failed',
+          shipment: shipment
+        )
+      end
+    end
+  end
+end

data/lib/solidus_backtracs/api/shipment_serializer.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Api
+    class ShipmentSerializer
+
+      def initialize(shipment:)
+        @shipment = shipment
+        @config = SolidusBacktracs.config
+        @property_id = ::Spree::Property.find_by(name: SolidusBacktracs.config.default_property_name)&.id
+      end
+
+      def call(sguid: nil)
+        order = @shipment.order
+        user = @shipment.user
+
+        xml = Builder::XmlMarkup.new 
+        xml.instruct!(:xml, :encoding => "UTF-8")
+
+        xml.soap(:Envelope, {"xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance", "xmlns:xsd" => "http://www.w3.org/2001/XMLSchema", "xmlns:soap" => "http://schemas.xmlsoap.org/soap/envelope/"}) do
+          xml.soap :Body do
+            xml.CreateNew({"xmlns" => "http://bactracs.andlor.com/rmaservice"}) do
+              xml.sGuid                       sguid
+              xml.NewRMA {
+                xml.RMANumber                 @shipment.number
+                xml.RMATypeName               @config.default_rma_type
+                xml.RMASubTypeName            
+                xml.CustomerRef               
+                xml.InboundShippingPriority   
+                xml.InboundTrackingNumber     @shipment.tracking
+
+                xml.Ship {
+                  xml.Carrier                 @config.default_carrier
+                  xml.ShipMethod              @config.default_ship_method
+                  xml.ShipDate                @shipment.created_at.strftime(SolidusBacktracs::ExportHelper::BACTRACS_DATE_FORMAT)
+                  xml.TrackingNumber          @shipment.tracking
+                  xml.SerialNumber            @shipment.number
+                  xml.Ud1                     
+                }
+                xml.Customer {
+                  SolidusBacktracs::ExportHelper.backtracs_address(xml, order, :ship)
+                  SolidusBacktracs::ExportHelper.backtracs_address(xml, order, :bill)
+                }
+                xml.Rep {
+                  xml.Code                    
+                  xml.Name                    user.full_name
+                  xml.Email                   user.email
+                }        
+
+                xml.RMALines {
+                  @shipment.line_items.each do |line|
+                    product = line.product
+                    if product.respond_to?(:assembly?) && product.assembly?
+                      product.parts.each do |part|
+                        next unless part.product.product_properties.where(property_id: @property_id).present?
+                        line_items_xml(xml: xml, line_item: line, variant: part, order: order)
+                      end
+                    else
+                      line_items_xml(xml: xml, line_item: line, variant: line.variant, order: order)
+                    end
+                  end
+                }
+                xml.OrderDate     order.completed_at.strftime(SolidusBacktracs::ExportHelper::BACTRACS_DATE_FORMAT)
+                xml.CreateDate    @shipment.created_at.strftime(SolidusBacktracs::ExportHelper::BACTRACS_DATE_FORMAT)
+                xml.Status        @config.default_status
+                xml.RMAId         @shipment.id
+                xml.ClientGuid
+              }
+            end
+          end 
+        end
+        xml
+      end
+
+      def line_items_xml(xml: nil, line_item: nil, variant: nil, order: nil)
+        shipment_notice = @shipment.shipment_notice        
+        xml.RMALine {
+          xml.DFItem                  find_sku_variant(variant)
+          xml.DFModelNum              find_sku_variant(variant)
+          xml.DFCategory              
+          xml.DFCategoryDescription   
+          xml.DFQuantity              line_item.quantity
+          xml.DFUnitPrice             line_item.price
+          xml.DFSerialNumbers         
+          xml.Ud1s                    
+          xml.CurrentWarranties       
+          xml.DFComments              
+          xml.DFStatus                @shipment.state
+          xml.PurchaseDate            order.completed_at.strftime(SolidusBacktracs::ExportHelper::BACTRACS_DATE_FORMAT)
+          xml.ServiceProvider         shipment_notice&.service
+          xml.WarrantyRepair          
+          xml.RMALineTest             
+          xml.InboundShipWeight       variant.weight.to_f
+          xml.RPLocation              @config.default_rp_location
+        } 
+      end
+
+      def find_sku_variant(variant)
+        @config.sku_map[variant.sku].present? ? @config.sku_map[variant.sku] : variant.sku
+      end
+    end
+  end
+end

data/lib/solidus_backtracs/api/threshold_verifier.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  module Api
+    class ThresholdVerifier
+      class << self
+        def call(shipment)
+          return false unless shipment.order.completed?
+
+          !!(shipment_requires_creation?(shipment) || shipment_requires_update?(shipment))
+        end
+
+        private
+
+        def shipment_requires_creation?(shipment)
+          shipment.backtracs_synced_at.nil? &&
+            Time.zone.now - shipment.order.updated_at < SolidusBacktracs.config.api_sync_threshold
+        end
+
+        def shipment_requires_update?(shipment)
+          shipment.backtracs_synced_at &&
+            shipment.backtracs_synced_at < shipment.order.updated_at &&
+            Time.zone.now - shipment.order.updated_at < SolidusBacktracs.config.api_sync_threshold
+        end
+      end
+    end
+  end
+end

data/lib/solidus_backtracs/configuration.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  class Configuration
+    attr_accessor(
+      :webhook_username,
+      :webhook_password,
+      :weight_units,
+      :ssl_encrypted,
+      :capture_at_notification,
+      :export_canceled_shipments,
+      :api_batch_size,
+      :api_sync_threshold,
+      :api_shipment_serializer,
+      :api_key,
+      :api_secret,
+      :api_shipment_matcher,
+      :error_handler,
+      :shipment_notice_class,
+      :authentication_username,
+      :authentication_password,
+      :api_base,
+      :api_retries,
+      :proxy_address,
+      :proxy_port,
+      :proxy_username,
+      :proxy_password,
+      :default_carrier,
+      :default_ship_method,
+      :default_rp_location,
+      :default_status,
+      :default_property_name,
+      :sku_map,
+      :default_rma_type,
+      :shippable_skus
+    )
+
+    def initialize
+      @api_batch_size = 100
+      @api_sync_threshold = 7.days
+      @error_handler = ->(_error, _extra = {}) {
+        Rails.logger.error "#{error.inspect} (#{extra.inspect})"
+      }
+      @api_shipment_matcher = proc do |backtracs_order, shipments|
+        shipments.find { |shipment| shipment.number == backtracs_order['orderNumber'] }
+      end
+
+      @shipment_notice_class = 'SolidusBacktracs::ShipmentNotice'
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    alias config configuration
+
+    def configure
+      yield configuration
+    end
+  end
+end

data/lib/solidus_backtracs/engine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'solidus_core'
+require 'solidus_support'
+
+module SolidusBacktracs
+  class Engine < Rails::Engine
+    include SolidusSupport::EngineExtensions
+
+    isolate_namespace ::Spree
+
+    engine_name 'solidus_backtracs'
+
+    # use rspec for tests
+    config.generators do |g|
+      g.test_framework :rspec
+    end
+  end
+end

data/lib/solidus_backtracs/errors.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  class Error < StandardError; end
+
+  class OrderNotPaidError < Error
+    def initialize(order, *args)
+      super("Order #{order.number} is not paid and capture_at_notification is false", *args)
+    end
+  end
+
+  class ShipmentNotFoundError < Error
+    def initialize(shipment_number, *args)
+      super("Could not find shipment with number #{shipment_number}", *args)
+    end
+  end
+
+  class PaymentError < Error
+    def initialize(payment, *args)
+      super("Could not process payment #{payment.id}", *args)
+    end
+  end
+end

data/lib/solidus_backtracs/shipment_notice.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  class ShipmentNotice
+    attr_reader :shipment_number, :shipment_tracking
+
+    class << self
+      def from_payload(params)
+        new(
+          shipment_number: params[:order_number],
+          shipment_tracking: params[:tracking_number],
+        )
+      end
+    end
+
+    def initialize(shipment_number:, shipment_tracking:)
+      @shipment_number = shipment_number
+      @shipment_tracking = shipment_tracking
+    end
+
+    def apply
+      unless shipment
+        raise ShipmentNotFoundError, shipment
+      end
+
+      process_payment
+      ship_shipment
+
+      shipment
+    end
+
+    private
+
+    def shipment
+      @shipment ||= ::Spree::Shipment.find_by(number: shipment_number)
+    end
+
+    def process_payment
+      return if shipment.order.paid?
+
+      unless SolidusBacktracs.configuration.capture_at_notification
+        raise OrderNotPaidError, shipment.order
+      end
+
+      shipment.order.payments.pending.each do |payment|
+        payment.capture!
+      rescue ::Spree::Core::GatewayError
+        raise PaymentError, payment
+      end
+    end
+
+    def ship_shipment
+      shipment.update!(tracking: shipment_tracking)
+      shipment.ship! if shipment.can_ship?
+      shipment.order.recalculate
+    end
+  end
+end

data/lib/solidus_backtracs/testing_support/factories.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+end

data/lib/solidus_backtracs/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolidusBacktracs
+  VERSION = '3.0.0'
+end

data/lib/solidus_backtracs.rb

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

data/solidus_bactracs.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'lib/solidus_backtracs/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'solidus_bactracs'
+  spec.version = SolidusBacktracs::VERSION
+  spec.authors = ['Zeryab Ali', 'Zachary Jones']
+  spec.email = 'techbilling@suvie.com'
+
+  spec.summary = 'A Solidus extension for integrating the Bactracs API.'
+  spec.homepage = 'https://github.com/suvie-eng/solidus_bactracs'
+  spec.license = 'BSD-3-Clause'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/suvie-eng/solidus_bactracs/'
+  spec.metadata['changelog_uri'] = 'https://github.com/suvie-eng/solidus_bactracs/blob/master/CHANGELOG.md'
+
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5')
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  files = Dir.chdir(__dir__) { `git ls-files -z`.split("\x0") }
+
+  spec.files = files.grep_v(%r{^(test|spec|features)/})
+  spec.test_files = files.grep(%r{^(test|spec|features)/})
+  spec.bindir = "exe"
+  spec.executables = files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'httparty', '~> 0.18'
+  spec.add_dependency 'solidus_core', ['>= 2.0.0', '< 4']
+  spec.add_dependency 'solidus_support', '~> 0.5'
+
+  spec.add_development_dependency 'rails-controller-testing'
+  spec.add_development_dependency 'rspec-xsd'
+  spec.add_development_dependency 'solidus_dev_support', '~> 2.5'
+  spec.add_development_dependency 'webmock'
+end

data/spec/controllers/spree/backtracs_controller_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+RSpec.describe Spree::BacktracsController do
+  render_views
+
+  describe '#export' do
+    context 'when the authentication is invalid' do
+      it 'returns an error error' do
+        get :export, params: { format: 'xml' }
+
+        expect(response.status).to eq(401)
+      end
+    end
+
+    context 'when the authentication is valid' do
+      it 'responds with 200 OK' do
+        stub_backtracs_auth
+        create(:order_ready_to_ship)
+
+        get :export,
+          params: {
+            start_date: 1.day.ago.strftime('%m/%d/%Y %H:%M'),
+            end_date: 1.day.from_now.strftime('%m/%d/%Y %H:%M'),
+            format: 'xml'
+          }
+
+        expect(response.status).to eq(200)
+      end
+
+      it 'generates Backtracs-compliant XML' do
+        stub_backtracs_auth
+        create(:order_ready_to_ship)
+
+        get :export, params: {
+          start_date: 1.day.ago.strftime('%m/%d/%Y %H:%M'),
+          end_date: 1.day.from_now.strftime('%m/%d/%Y %H:%M'),
+          format: 'xml'
+        }
+
+        expect(response.body).to pass_validation('spec/fixtures/backtracs_xml_schema.xsd')
+      end
+    end
+  end
+
+  describe '#shipnotify' do
+    context 'when the authentication is valid' do
+      context 'when the shipment can be found' do
+        it 'responds with 200 OK' do
+          stub_backtracs_auth
+          shipment = create(:order_ready_to_ship).shipments.first
+
+          post :shipnotify, params: {
+            order_number: shipment.number,
+            tracking_number: '123456',
+            format: 'xml',
+          }
+          shipment.reload
+
+          expect(response.status).to eq(200)
+        end
+
+        it 'updates the shipment' do
+          stub_backtracs_auth
+          shipment = create(:order_ready_to_ship).shipments.first
+
+          post :shipnotify, params: {
+            order_number: shipment.number,
+            tracking_number: '123456',
+            format: 'xml',
+          }
+          shipment.reload
+
+          expect(shipment).to have_attributes(
+            tracking: '123456',
+            state: 'shipped',
+            shipped_at: an_instance_of(ActiveSupport::TimeWithZone),
+          )
+        end
+      end
+
+      context 'when the shipment cannot be found' do
+        it 'responds with 400 Bad Request' do
+          stub_backtracs_auth
+          shipment = create(:order_ready_to_ship).shipments.first
+
+          post :shipnotify, params: {
+            order_number: 'ABC123',
+            tracking_number: '123456',
+            format: 'xml',
+          }
+          shipment.reload
+
+          expect(response.status).to eq(400)
+        end
+      end
+    end
+  end
+
+  def stub_backtracs_auth(username = 'mario', password = 'lemieux')
+    stub_configuration(username: username, password: password)
+    request.headers['Authorization'] = ActionController::HttpAuthentication::Basic.encode_credentials(username, password)
+  end
+end