active_fulfillment 2.1.9 → 3.0.0.pre2

data/lib/active_fulfillment/services/james_and_james.rb

@@ -0,0 +1,122 @@
+require 'json'
+
+module ActiveFulfillment
+  class JamesAndJamesService < Service
+
+    SERVICE_URLS = {
+      fulfillment: 'https://%{subdomain}.sixworks.co.uk/api/1/',
+      inventory: 'https://%{subdomain}.sixworks.co.uk/api/1/stock'
+    }
+
+    def initialize(options = {})
+      requires!(options, :subdomain, :key)
+      super
+    end
+
+    def fulfill(order_id, shipping_address, line_items, options = {})
+      requires!(options, :billing_address)
+      commit :fulfillment, build_fulfillment_request(order_id, shipping_address, line_items, options)
+    end
+
+    def fetch_stock_levels(options = {})
+      get :inventory, build_inventory_request(options)
+    end
+
+    def test_mode?
+      true
+    end
+
+    private
+
+    def build_fulfillment_request(order_id, shipping_address, line_items, options)
+      data = {
+        order: {
+          client_ref: order_id,
+          ShippingContact: format_address(shipping_address),
+          BillingContact: format_address(options[:billing_address]),
+          items: format_line_items(line_items)
+        }
+      }
+      data[:allow_preorder] = options[:allow_preorder] unless options[:allow_preorder].blank?
+      data[:update_stock] = options[:update_stock] unless options[:update_stock].blank?
+      data[:order][:po_number] = options[:po_number] unless options[:po_number].blank?
+      data[:order][:date_placed] = options[:date_placed] unless options[:po_number].blank?
+      data[:order][:postage_speed] = options[:postage_speed] unless options[:postage_speed].blank?
+      data[:order][:postage_cost] = options[:postage_cost] unless options[:postage_cost].blank?
+      data[:order][:total_value] = options[:total_value] unless options[:total_value].blank?
+      data[:order][:days_before_bbe] = options[:days_before_bbe] unless options[:days_before_bbe].blank?
+      data[:order][:callback_url] = options[:callback_url] unless options[:callback_url].blank?
+      return data
+    end
+
+    def build_inventory_request(options)
+      {}
+    end
+
+    def commit(action, request)
+      request = request.merge({api_key: @options[:key], test: test? })
+      data = ssl_post(SERVICE_URLS[action] % {subdomain: @options[:subdomain]}, JSON.generate(request))
+      response = parse_response(data)
+      Response.new(response["success"], "message", response, test: response["test"])
+    rescue ActiveUtils::ResponseError => e
+      handle_error(e)
+    rescue JSON::ParserError => e
+      Response.new(false, e.message)
+    end
+
+    def get(action, request)
+      request = request.merge({api_key: @options[:key], test: test? })
+      data = ssl_get(SERVICE_URLS[action] % {subdomain: @options[:subdomain]} + "?" + request.to_query)
+      response = parse_response(data)
+      Response.new(response["success"], "message", response, test: response["test"])
+    rescue ActiveUtils::ResponseError => e
+      handle_error(e)
+    rescue JSON::ParserError => e
+      Response.new(false, e.message)
+    end
+
+    def parse_response(json)
+      JSON.parse(json)
+    end
+
+    def handle_error(e)
+      response = parse_error(e.response)
+      Response.new(false, response[:http_message], response)
+    end
+
+    def parse_error(http_response)
+      response = {}
+      response[:http_code] = http_response.code
+      response[:http_message] = http_response.message
+      response
+    end
+
+    def format_address(address)
+      data = {
+        name: address[:name],
+        address: address[:address1],
+        city: address[:city],
+        country: address[:country],
+        postcode: address[:zip].blank? ? "-" : address[:zip]
+      }
+      data[:company] = address[:company] unless address[:company].blank?
+      data[:email] = address[:email] unless address[:email].blank?
+      data[:address_contd] = address[:address2] unless address[:address2].blank?
+      data[:county] = address[:state] unless address[:state].blank?
+      return data
+    end
+
+    def format_line_items(items)
+      data = []
+      items.each do |item|
+        data << {
+          client_ref: item[:sku],
+          quantity: item[:quantity],
+          price: item[:price]
+        }
+      end
+      return data
+    end
+
+  end
+end

data/lib/active_fulfillment/services/shipwire.rb

@@ -0,0 +1,266 @@
+require 'cgi'
+
+module ActiveFulfillment
+  class ShipwireService < Service
+
+    SERVICE_URLS = { :fulfillment  => 'https://api.shipwire.com/exec/FulfillmentServices.php',
+                     :inventory    => 'https://api.shipwire.com/exec/InventoryServices.php',
+                     :tracking     => 'https://api.shipwire.com/exec/TrackingServices.php'
+                   }
+
+    SCHEMA_URLS = { :fulfillment => 'http://www.shipwire.com/exec/download/OrderList.dtd',
+                    :inventory   => 'http://www.shipwire.com/exec/download/InventoryUpdate.dtd',
+                    :tracking    => 'http://www.shipwire.com/exec/download/TrackingUpdate.dtd'
+                  }
+
+    POST_VARS = { :fulfillment => 'OrderListXML',
+                  :inventory   => 'InventoryUpdateXML',
+                  :tracking    => 'TrackingUpdateXML'
+                }
+
+    WAREHOUSES = { 'CHI' => 'Chicago',
+                   'LAX' => 'Los Angeles',
+                   'REN' => 'Reno',
+                   'VAN' => 'Vancouver',
+                   'TOR' => 'Toronto',
+                   'UK'  => 'United Kingdom'
+                 }
+
+    INVALID_LOGIN = /(Error with Valid Username\/EmailAddress and Password Required)|(Could not verify Username\/EmailAddress and Password combination)/
+
+    class_attribute :affiliate_id
+
+    # The first is the label, and the last is the code
+    def self.shipping_methods
+      [ ['1 Day Service',   '1D'],
+        ['2 Day Service',   '2D'],
+        ['Ground Service',  'GD'],
+        ['Freight Service', 'FT'],
+        ['International', 'INTL']
+      ].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 = {})
+      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)
+    end
+
+    def valid_credentials?
+      response = fetch_tracking_numbers([])
+      response.message !~ INVALID_LOGIN
+    end
+
+    def test_mode?
+      true
+    end
+
+    def include_pending_stock?
+      @options[:include_pending_stock]
+    end
+
+    def include_empty_stock?
+      @options[:include_empty_stock]
+    end
+
+    private
+    def build_fulfillment_request(order_id, shipping_address, line_items, options)
+      xml = Builder::XmlMarkup.new :indent => 2
+      xml.instruct!
+      xml.declare! :DOCTYPE, :OrderList, :SYSTEM, SCHEMA_URLS[:fulfillment]
+      xml.tag! 'OrderList' do
+        add_credentials(xml)
+        xml.tag! 'Referer', 'Active Fulfillment'
+        add_order(xml, order_id, shipping_address, line_items, options)
+      end
+      xml.target!
+    end
+
+    def build_inventory_request(options)
+      xml = Builder::XmlMarkup.new :indent => 2
+      xml.instruct!
+      xml.declare! :DOCTYPE, :InventoryStatus, :SYSTEM, SCHEMA_URLS[:inventory]
+      xml.tag! 'InventoryUpdate' do
+        add_credentials(xml)
+        xml.tag! 'Warehouse', WAREHOUSES[options[:warehouse]]
+        xml.tag! 'ProductCode', options[:sku]
+        xml.tag! 'IncludeEmpty' if include_empty_stock?
+      end
+    end
+
+    def build_tracking_request(order_ids)
+      xml = Builder::XmlMarkup.new
+      xml.instruct!
+      xml.declare! :DOCTYPE, :InventoryStatus, :SYSTEM, SCHEMA_URLS[:inventory]
+      xml.tag! 'TrackingUpdate' do
+        add_credentials(xml)
+        xml.tag! 'Server', test? ? 'Test' : 'Production'
+        order_ids.each do |o_id|
+          xml.tag! 'OrderNo', o_id
+        end
+      end
+    end
+
+    def add_credentials(xml)
+      xml.tag! 'EmailAddress', @options[:login]
+      xml.tag! 'Password', @options[:password]
+      xml.tag! 'Server', test? ? 'Test' : 'Production'
+      xml.tag! 'AffiliateId', affiliate_id if affiliate_id.present?
+    end
+
+    def add_order(xml, order_id, shipping_address, line_items, options)
+      xml.tag! 'Order', :id => order_id do
+        xml.tag! 'Warehouse', options[:warehouse] || '00'
+
+        add_address(xml, shipping_address, options)
+        xml.tag! 'Shipping', options[:shipping_method] unless options[:shipping_method].blank?
+
+        Array(line_items).each_with_index do |line_item, index|
+          add_item(xml, line_item, index)
+        end
+        xml.tag! 'Note' do
+          xml.cdata! options[:note] unless options[:note].blank?
+        end
+      end
+    end
+
+    def add_address(xml, address, options)
+      xml.tag! 'AddressInfo', :type => 'Ship' do
+        xml.tag! 'Name' do
+          xml.tag! 'Full', address[:name]
+        end
+
+        xml.tag! 'Address1', address[:address1]
+        xml.tag! 'Address2', address[:address2]
+
+        xml.tag! 'Company', address[:company]
+
+        xml.tag! 'City', address[:city]
+        xml.tag! 'State', address[:state] unless address[:state].blank?
+        xml.tag! 'Country', address[:country]
+
+        xml.tag! 'Zip', address[:zip]
+        xml.tag! 'Phone', address[:phone] unless address[:phone].blank?
+        xml.tag! 'Email', options[:email] unless options[:email].blank?
+      end
+    end
+
+    # Code is limited to 12 characters
+    def add_item(xml, item, index)
+      xml.tag! 'Item', :num => index do
+        xml.tag! 'Code', item[:sku]
+        xml.tag! 'Quantity', item[:quantity]
+      end
+    end
+
+    def commit(action, request)
+      data = ssl_post(SERVICE_URLS[action], "#{POST_VARS[action]}=#{CGI.escape(request)}")
+
+      response = parse_response(action, data)
+      Response.new(response[:success], response[:message], response, :test => test?)
+    end
+
+    def parse_response(action, data)
+      case action
+      when :fulfillment
+        parse_fulfillment_response(data)
+      when :inventory
+        parse_inventory_response(data)
+      when :tracking
+        parse_tracking_response(data)
+      else
+        raise ArgumentError, "Unknown action #{action}"
+      end
+    end
+
+    def parse_fulfillment_response(xml)
+      response = {}
+
+      document = REXML::Document.new(xml)
+      document.root.elements.each do |node|
+        response[node.name.underscore.to_sym] = text_content(node)
+      end
+
+      response[:success] = response[:status] == '0'
+      response[:message] = response[:success] ? "Successfully submitted the order" : message_from(response[:error_message])
+      response
+    end
+
+    def parse_inventory_response(xml)
+      response = {}
+      response[:stock_levels] = {}
+
+      document = REXML::Document.new(xml)
+      document.root.elements.each do |node|
+        if node.name == 'Product'
+          to_check = ['quantity']
+          to_check << 'pending' if include_pending_stock?
+
+          amount = to_check.sum { |a| node.attributes[a].to_i }
+          response[:stock_levels][node.attributes['code']] = amount
+        else
+          response[node.name.underscore.to_sym] = text_content(node)
+        end
+      end
+
+      response[:success] = test? ? response[:status] == 'Test' : response[:status] == '0'
+      response[:message] = response[:success] ? "Successfully received the stock levels" : message_from(response[:error_message])
+
+      response
+    end
+
+    def parse_tracking_response(xml)
+      response = {}
+      response[:tracking_numbers] = {}
+      response[:tracking_companies] = {}
+      response[:tracking_urls] = {}
+
+      document = REXML::Document.new(xml)
+      document.root.elements.each do |node|
+        if node.name == 'Order'
+          if node.attributes["shipped"] == "YES" && node.elements['TrackingNumber']
+            tracking_number = node.elements['TrackingNumber'].text.strip
+            response[:tracking_numbers][node.attributes['id']] = [tracking_number]
+
+            tracking_company = node.elements['TrackingNumber'].attributes['carrier']
+            response[:tracking_companies][node.attributes['id']] = [tracking_company.strip] if tracking_company
+
+            tracking_url = node.elements['TrackingNumber'].attributes['href']
+            response[:tracking_urls][node.attributes['id']] = [tracking_url.strip] if tracking_url
+          end
+        else
+          response[node.name.underscore.to_sym] = text_content(node)
+        end
+      end
+
+      response[:success] = test? ? (response[:status] == '0' || response[:status] == 'Test') : response[:status] == '0'
+      response[:message] = response[:success] ? "Successfully received the tracking numbers" : message_from(response[:error_message])
+      response
+    end
+
+    def message_from(string)
+      return if string.blank?
+      string.gsub("\n", '').squeeze(" ")
+    end
+
+    def text_content(xml_node)
+      text = xml_node.text
+      text = xml_node.cdatas.join if text.blank?
+      text
+    end
+  end
+end

data/lib/active_fulfillment/services/shopify_api.rb

@@ -0,0 +1,125 @@
+require 'active_support/core_ext/object/to_query'
+
+module ActiveFulfillment
+  class ShopifyAPIService < Service
+
+    OrderIdCutoffDate = Date.iso8601("2015-03-01")
+
+    RESCUABLE_CONNECTION_ERRORS = [
+      Net::ReadTimeout,
+      Net::OpenTimeout,
+      TimeoutError,
+      Errno::ETIMEDOUT,
+      Timeout::Error,
+      IOError,
+      EOFError,
+      SocketError,
+      Errno::ECONNRESET,
+      Errno::ECONNABORTED,
+      Errno::EPIPE,
+      Errno::ECONNREFUSED,
+      Errno::EAGAIN,
+      Errno::EHOSTUNREACH,
+      Errno::ENETUNREACH,
+      Resolv::ResolvError,
+      Net::HTTPBadResponse,
+      Net::HTTPHeaderSyntaxError,
+      Net::ProtocolError,
+      ActiveUtils::ConnectionError,
+      ActiveUtils::ResponseError,
+      ActiveUtils::InvalidResponseError
+    ]
+
+    def initialize(options = {})
+      @name = options[:name]
+      @callback_url = options[:callback_url]
+      @format = options[:format]
+    end
+
+    def fulfill(order_id, shipping_address, line_items, options = {})
+      raise NotImplementedError.new("Shopify API Service must listen to fulfillment/create Webhooks")
+    end
+
+    def fetch_stock_levels(options = {})
+      response = send_app_request('fetch_stock', options.delete(:headers), options)
+      if response
+        stock_levels = parse_response(response, 'StockLevels', 'Product', 'Sku', 'Quantity') { |p| p.to_i }
+        Response.new(true, "API stock levels", {:stock_levels => stock_levels})
+      else
+        Response.new(false, "Unable to fetch remote stock levels")
+      end
+    end
+
+    def fetch_tracking_data(order_numbers, options = {})
+      options.merge!({:order_ids => order_numbers, :order_names => order_numbers})
+      response = send_app_request('fetch_tracking_numbers', options.delete(:headers), options)
+      if response
+        tracking_numbers = parse_response(response, 'TrackingNumbers', 'Order', 'ID', 'Tracking') { |o| o }
+        Response.new(true, "API tracking_numbers", {:tracking_numbers => tracking_numbers,
+                                                    :tracking_companies => {},
+                                                    :tracking_urls => {}})
+      else
+        Response.new(false, "Unable to fetch remote tracking numbers #{order_numbers.inspect}")
+      end
+    end
+
+    private
+
+    def request_uri(action, data)
+      URI.parse "#{@callback_url}/#{action}.#{@format}?#{data.to_query}"
+    end
+
+    def send_app_request(action, headers, data)
+      uri = request_uri(action, data)
+
+      logger.info "[" + @name.upcase + " APP] Post #{uri}"
+
+      response = nil
+      realtime = Benchmark.realtime do
+        begin
+          Timeout.timeout(20.seconds) do
+            response = ssl_get(uri, headers)
+          end
+        rescue *(RESCUABLE_CONNECTION_ERRORS) => e
+          logger.warn "[#{self}] Error while contacting fulfillment service error =\"#{e.message}\""
+        end
+      end
+
+      line = "[" + @name.upcase + "APP] Response from #{uri} --> "
+      line << "#{response} #{"%.4fs" % realtime}"
+      logger.info line
+
+      response
+    end
+
+    def parse_response(response, root, type, key, value)
+      case @format
+      when 'json'
+        response_data = ActiveSupport::JSON.decode(response)
+        return {} unless response_data.is_a?(Hash)
+        response_data[root.underscore] || response_data
+      when 'xml'
+        response_data = {}
+        document = REXML::Document.new(response)
+        document.elements[root].each do |node|
+          if node.name == type
+            response_data[node.elements[key].text] = node.elements[value].text
+          end
+        end
+        response_data
+      end
+
+    rescue ActiveSupport::JSON.parse_error, REXML::ParseException
+      {}
+    end
+
+    def encode_payload(payload, root)
+      case @format
+      when 'json'
+        {root => payload}.to_json
+      when 'xml'
+        payload.to_xml(:root => root)
+      end
+    end
+  end
+end