active_fulfillment 2.1.9 → 3.0.0.pre2

data/lib/active_fulfillment/services/webgistix.rb

@@ -0,0 +1,334 @@
+module ActiveFulfillment
+  class WebgistixService < Service
+    SERVICE_URLS = {
+      :fulfillment => 'https://www.webgistix.com/XML/CreateOrder.asp',
+      :inventory   => 'https://www.webgistix.com/XML/GetInventory.asp',
+      :tracking    => 'https://www.webgistix.com/XML/GetTracking.asp'
+    }
+    TEST_URLS = SERVICE_URLS.merge({
+      :fulfillment => 'https://www.webgistix.com/XML/CreateOrderTest.asp'
+    })
+
+    SUCCESS, DUPLICATE, FAILURE = 'True', 'Duplicate', 'False'
+
+    SUCCESS_MESSAGE = 'Successfully submitted the order'
+    FAILURE_MESSAGE = 'Failed to submit the order'
+    DUPLICATE_MESSAGE = 'This order has already been successfully submitted'
+
+    INVALID_LOGIN = 'Invalid Credentials'
+    NOT_SHIPPED = 'Not Shipped'
+
+    TRACKING_COMPANIES = %w(UPS FedEx USPS)
+
+    # If a request is detected as a duplicate only the original data will be
+    # used by Webgistix, and the subsequent responses will have a
+    # :duplicate parameter set in the params hash.
+    self.retry_safe = true
+
+    # The first is the label, and the last is the code
+    def self.shipping_methods
+      [
+        ["UPS Ground Shipping", "Ground"],
+        ["UPS Ground", "Ground"],
+        ["UPS Standard Shipping (Canada Only)", "Standard"],
+        ["UPS Standard Shipping (CA & MX Only)", "Standard"],
+        ["UPS 3-Business Day", "3-Day Select"],
+        ["UPS 2-Business Day", "2nd Day Air"],
+        ["UPS 2-Business Day AM", "2nd Day Air AM"],
+        ["UPS Next Day", "Next Day Air"],
+        ["UPS Next Day Saver", "Next Day Air Saver"],
+        ["UPS Next Day Early AM", "Next Day Air Early AM"],
+        ["UPS Worldwide Express (Next Day)", "Worldwide Express"],
+        ["UPS Worldwide Expedited (2nd Day)", "Worldwide Expedited"],
+        ["UPS Worldwide Express Saver", "Worldwide Express Saver"],
+        ["FedEx Priority Overnight", "FedEx Priority Overnight"],
+        ["FedEx Standard Overnight", "FedEx Standard Overnight"],
+        ["FedEx First Overnight", "FedEx First Overnight"],
+        ["FedEx 2nd Day", "FedEx 2nd Day"],
+        ["FedEx Express Saver", "FedEx Express Saver"],
+        ["FedEx International Priority", "FedEx International Priority"],
+        ["FedEx International Economy", "FedEx International Economy"],
+        ["FedEx International First", "FedEx International First"],
+        ["FedEx Ground", "FedEx Ground"],
+        ["USPS Priority Mail", "Priority Mail"],
+        ["USPS Priority Mail International", "Priority Mail International"],
+        ["USPS Priority Mail Small Flat Rate Box", "Priority Mail Small Flat Rate Box"],
+        ["USPS Priority Mail Medium Flat Rate Box", "Priority Mail Medium Flat Rate Box"],
+        ["USPS Priority Mail Large Flat Rate Box", "Priority Mail Large Flat Rate Box"],
+        ["USPS Priority Mail Flat Rate Envelope", "Priority Mail Flat Rate Envelope"],
+        ["USPS First Class Mail", "First Class"],
+        ["USPS First Class International", "First Class International"],
+        ["USPS Express Mail", "Express"],
+        ["USPS Express Mail International", "Express Mail International"],
+        ["USPS Parcel Post", "Parcel"],
+        ["USPS Media Mail", "Media Mail"]
+      ].inject({}){|h, (k,v)| h[k] = v; h}
+    end
+
+    # Pass in the login and password for the shipwire account.
+    # Optionally pass in the :test => true to force test mode
+    def initialize(options = {})
+      requires!(options, :login, :password)
+      super
+    end
+
+    def fulfill(order_id, shipping_address, line_items, options = {})
+      requires!(options, :shipping_method)
+      commit :fulfillment, build_fulfillment_request(order_id, shipping_address, line_items, options)
+    end
+
+    def fetch_stock_levels(options = {})
+      commit :inventory, build_inventory_request(options)
+    end
+
+    def fetch_tracking_data(order_ids, options = {})
+      commit :tracking, build_tracking_request(order_ids, options)
+    end
+
+    def valid_credentials?
+      response = fulfill('', {}, [], :shipping_method => '')
+      response.message != INVALID_LOGIN
+    end
+
+    def test_mode?
+      true
+    end
+
+    private
+    #<?xml version="1.0"?>
+    # <OrderXML>
+    #   <Password>Webgistix</Password>
+    #   <CustomerID>3</CustomerID>
+    #   <Order>
+    #     <ReferenceNumber></ReferenceNumber>
+    #     <Company>Test Company</Company>
+    #     <Name>Joe Smith</Name>
+    #     <Address1>123 Main St.</Address1>
+    #     <Address2></Address2>
+    #     <Address3></Address3>
+    #     <City>Olean</City>
+    #     <State>NY</State>
+    #     <ZipCode>14760</ZipCode>
+    #     <Country>United States</Country>
+    #     <Email>info@webgistix.com</Email>
+    #     <Phone>1-123-456-7890</Phone>
+    #     <ShippingInstructions>Ground</ShippingInstructions>
+    #     <OrderComments>Test Order</OrderComments>
+    #     <Approve>0</Approve>
+    #     <Item>
+    #      <ItemID>testitem</ItemID>
+    #      <ItemQty>2</ItemQty>
+    #     </Item>
+    #   </Order>
+    # </OrderXML>
+    def build_fulfillment_request(order_id, shipping_address, line_items, options)
+      xml = Builder::XmlMarkup.new :indent => 2
+      xml.instruct!
+      xml.tag! 'OrderXML' do
+        add_credentials(xml)
+        add_order(xml, order_id, shipping_address, line_items, options)
+      end
+      xml.target!
+    end
+
+    #<?xml version="1.0"?>
+    # <InventoryXML>
+    #   <Password>Webgistix</Password>
+    #   <CustomerID>3</CustomerID>
+    # </InventoryXML>
+    def build_inventory_request(options)
+      xml = Builder::XmlMarkup.new :indent => 2
+      xml.instruct!
+      xml.tag! 'InventoryXML' do
+        add_credentials(xml)
+      end
+    end
+
+    #<?xml version="1.0"?>
+    # <TrackingXML>
+    #   <Password>Webgistix</Password>
+    #   <CustomerID>3</CustomerID>
+    #   <Tracking>
+    #     <Order>AB12345</Order>
+    #   </Tracking>
+    #   <Tracking>
+    #     <Order>XY4567</Order>
+    #   </Tracking>
+    # </TrackingXML>
+    def build_tracking_request(order_ids, options)
+      xml = Builder::XmlMarkup.new :indent => 2
+      xml.instruct!
+      xml.tag! 'TrackingXML' do
+        add_credentials(xml)
+
+        order_ids.each do |o_id|
+          xml.tag! 'Tracking' do
+            xml.tag! 'Order', o_id
+          end
+        end
+      end
+    end
+
+    def add_credentials(xml)
+      xml.tag! 'CustomerID', @options[:login]
+      xml.tag! 'Password', @options[:password]
+    end
+
+    def add_order(xml, order_id, shipping_address, line_items, options)
+      xml.tag! 'Order' do
+        xml.tag! 'ReferenceNumber', order_id
+        xml.tag! 'ShippingInstructions', options[:shipping_method]
+        xml.tag! 'Approve', 1
+        xml.tag! 'OrderComments', options[:comment] unless options[:comment].blank?
+
+        add_address(xml, shipping_address, options)
+
+        Array(line_items).each_with_index do |line_item, index|
+          add_item(xml, line_item, index)
+        end
+      end
+    end
+
+    def add_address(xml, address, options)
+      xml.tag! 'Name', address[:name]
+      xml.tag! 'Address1', address[:address1]
+      xml.tag! 'Address2', address[:address2] unless address[:address2].blank?
+      xml.tag! 'Address3', address[:address3] unless address[:address3].blank?
+      xml.tag! 'City', address[:city]
+      xml.tag! 'State', address[:state]
+      xml.tag! 'ZipCode', address[:zip]
+      xml.tag! 'Company', address[:company]
+
+      unless address[:country].blank?
+        country = ActiveUtils::Country.find(address[:country])
+        xml.tag! 'Country', country.name
+      end
+
+      xml.tag! 'Phone', address[:phone]
+      xml.tag! 'Email', options[:email] unless options[:email].blank?
+    end
+
+    def add_item(xml, item, index)
+      xml.tag! 'Item' do
+        xml.tag! 'ItemID', item[:sku] unless item[:sku].blank?
+        xml.tag! 'ItemQty', item[:quantity] unless item[:quantity].blank?
+      end
+    end
+
+    def commit(action, request)
+      url = test? ? TEST_URLS[action] : SERVICE_URLS[action]
+
+      data = ssl_post(url, request,
+        'EndPointURL'  => url,
+        'Content-Type' => 'text/xml; charset="utf-8"'
+      )
+
+      response = parse_response(action, data)
+      Response.new(success?(response), message_from(response), response, :test => test?)
+    end
+
+    def success?(response)
+      response[:success] == SUCCESS || response[:success] == DUPLICATE
+    end
+
+    def message_from(response)
+      if response[:duplicate]
+        DUPLICATE_MESSAGE
+      elsif success?(response)
+        SUCCESS_MESSAGE
+      elsif response[:error_0] == INVALID_LOGIN
+        INVALID_LOGIN
+      else
+        FAILURE_MESSAGE
+      end
+    end
+
+    def parse_response(action, xml)
+      begin
+        document = REXML::Document.new("<response>#{xml}</response>")
+      rescue REXML::ParseException
+        return {:success => FAILURE}
+      end
+
+      case action
+      when :fulfillment
+        parse_fulfillment_response(document)
+      when :inventory
+        parse_inventory_response(document)
+      when :tracking
+        parse_tracking_response(document)
+      else
+        raise ArgumentError, "Unknown action #{action}"
+      end
+    end
+
+    def parse_fulfillment_response(document)
+      response = parse_errors(document)
+
+      # Check if completed
+      if completed = REXML::XPath.first(document, '//Completed')
+        completed.elements.each do |e|
+          response[e.name.underscore.to_sym] = e.text
+        end
+      else
+        response[:success] = FAILURE
+      end
+
+      response[:duplicate] = response[:success] == DUPLICATE
+
+      response
+    end
+
+    def parse_inventory_response(document)
+      response = parse_errors(document)
+      response[:stock_levels] = {}
+
+      document.root.each_element('//Item') do |node|
+        # {ItemID => 'SOME-ID', ItemQty => '101'}
+        params = node.elements.to_a.each_with_object({}) {|elem, hash| hash[elem.name] = elem.text}
+
+        response[:stock_levels][params['ItemID']] = params['ItemQty'].to_i
+      end
+
+      response
+    end
+
+    def parse_tracking_response(document)
+      response = parse_errors(document)
+      response[:tracking_numbers] = {}
+      response[:tracking_companies] = {}
+      response[:tracking_urls] = {}
+
+      document.root.each_element('//Shipment') do |node|
+        # {InvoiceNumber => 'SOME-ID', ShipmentTrackingNumber => 'SOME-TRACKING-NUMBER'}
+        params = node.elements.to_a.each_with_object({}) {|elem, hash| hash[elem.name] = elem.text}
+
+        tracking = params['ShipmentTrackingNumber']
+
+        unless tracking == NOT_SHIPPED
+          response[:tracking_numbers][params['InvoiceNumber']] ||= []
+          response[:tracking_numbers][params['InvoiceNumber']] << tracking
+        end
+
+        company = params['Method'].split[0] if params['Method']
+        if TRACKING_COMPANIES.include? company
+          response[:tracking_companies][params['InvoiceNumber']] ||= []
+          response[:tracking_companies][params['InvoiceNumber']] << company
+        end
+      end
+
+      response
+    end
+
+    def parse_errors(document)
+      response = {}
+
+      REXML::XPath.match(document, "//Errors/Error").to_a.each_with_index do |e, i|
+        response["error_#{i}".to_sym] = e.text
+      end
+
+      response[:success] = response.empty? ? SUCCESS : FAILURE
+      response
+    end
+  end
+end

data/lib/active_fulfillment/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module ActiveFulfillment
+  VERSION = "3.0.0.pre2"
+end

data/test/remote/amazon_mws_test.rb

@@ -1,9 +1,10 @@
 require 'test_helper'
 
-class RemoteAmazonMarketplaceWebservicesTest < Test::Unit::TestCase
+class RemoteAmazonMarketplaceWebservicesTest < Minitest::Test
+  include ActiveFulfillment::Test::Fixtures
 
   def setup
-    @service = AmazonMarketplaceWebService.new( fixtures(:amazon_mws) )
+    @service = ActiveFulfillment::AmazonMarketplaceWebService.new(fixtures(:amazon_mws))
 
     @options = {
       :shipping_method => 'Standard',
@@ -30,9 +31,9 @@ class RemoteAmazonMarketplaceWebservicesTest < Test::Unit::TestCase
   end
 
   def test_successful_order_submission
-    response = @service.fulfill(ActiveMerchant::Utils.generate_unique_id, @address, @line_items, @options)
+    response = @service.fulfill(SecureRandom.uuid, @address, @line_items, @options)
     assert response.success?
-    assert !response.test?
+    refute response.test?
   end
 
   def test_order_multiple_line_items
@@ -41,17 +42,17 @@ class RemoteAmazonMarketplaceWebservicesTest < Test::Unit::TestCase
                        :quantity => 2
                      })
 
-    response = @service.fulfill(ActiveMerchant::Utils.generate_unique_id, @address, @line_items, @options)
+    response = @service.fulfill(SecureRandom.uuid, @address, @line_items, @options)
     assert response.success?
   end
 
   def test_invalid_credentials_during_fulfillment
-    service = AmazonMarketplaceWebService.new(
+    service = ActiveFulfillment::AmazonMarketplaceWebService.new(
       :login => 'y',
       :password => 'p',
       :seller_id => 'o')
 
-    response = service.fulfill(ActiveMerchant::Utils.generate_unique_id, @address, @line_items, @options)
+    response = service.fulfill(SecureRandom.uuid, @address, @line_items, @options)
     assert !response.success?
 
     assert_equal "InvalidAccessKeyId: The AWS Access Key Id you provided does not exist in our records.", response.response_comment
@@ -98,23 +99,25 @@ class RemoteAmazonMarketplaceWebservicesTest < Test::Unit::TestCase
   end
 
   def test_invalid_credentials
-    service = AmazonMarketplaceWebService.new(
+    service = ActiveFulfillment::AmazonMarketplaceWebService.new(
       :login => 'your@email.com',
-      :password => 'password',
+      :password => 'wrong',
       :seller_id => 'SellerNumber1')
-    assert !service.valid_credentials?
+    refute service.valid_credentials?
   end
 
-  def test_get_status_does_not_require_valid_credentials
-    service = AmazonMarketplaceWebService.new(
-      :login => 'your@email.com',
-      :password => 'password')
-    response = service.status
+  def test_get_status
+    response = @service.status
     assert response.success?
   end
 
-  def test_get_status
-    service = AmazonMarketplaceWebService.new(fixtures(:amazon))
+  def test_get_status_does_not_require_valid_credentials
+    service = ActiveFulfillment::AmazonMarketplaceWebService.new(
+      :login => 'your@email.com',
+      :password => 'wrong',
+      :seller_id => 'SellerNumber1'
+    )
+
     response = service.status
     assert response.success?
   end

data/test/remote/james_and_james_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+
+class RemoteJamesAndJamesTest < Minitest::Test
+  include ActiveFulfillment::Test::Fixtures
+
+  def setup
+    ActiveFulfillment::Base.mode = :test
+
+    @service = ActiveFulfillment::JamesAndJamesService.new(fixtures(:james_and_james))
+
+    @options = {
+      shipping_method: 'Ground',
+      email:    'buyer@jadedpallet.com'
+    }
+
+    @address = {
+      name: 'Fred Brooks',
+      address1: '1234 Penny Lane',
+      city: 'Jonsetown',
+      state: 'NC',
+      country: 'US',
+      zip: '23456'
+    }
+
+    @line_items = [
+      {
+        sku: 'SBLK8',
+        quantity: 2,
+        price: 10
+      }
+    ]
+
+  end
+
+  def test_successful_order_submission
+    @options[:billing_address] = @address
+    response = @service.fulfill('123456', @address, @line_items, @options)
+    assert response.success?
+    assert response.test?
+  end
+
+  def test_order_multiple_line_items
+    @line_items.push({
+      sku: 'SWHT8',
+      quantity: 3,
+      price: 10
+    })
+    @options[:billing_address] = @address
+    response = @service.fulfill('123456', @address, @line_items, @options)
+    assert response.success?
+    assert response.test?
+  end
+
+  def test_invalid_sku_during_fulfillment
+    line_items = [{sku: 'invalid', quantity: 1}]
+    @options[:billing_address] = @address
+    response = @service.fulfill('123456', @address, line_items, @options)
+    assert !response.success?
+    assert response.test?
+  end
+
+  def test_invalid_credentials_during_fulfillment
+    service = ActiveFulfillment::JamesAndJamesService.new(subdomain: 'test', key: 'test')
+    @options[:billing_address] = @address
+    response = service.fulfill('123456', @address, @line_items, @options)
+    refute response.success?
+    assert_equal "Not Found", response.message
+  end
+
+  def test_get_inventory
+    response = @service.fetch_stock_levels
+    assert response.success?
+    assert response.test?
+    assert_equal 99,  response.stock['SBLK8']
+  end
+
+end