eldorado 0.0.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 22fbc7b5eb0223ed26f464cf7140d49981931967
+  data.tar.gz: 91a81fc97bf1ed96f95abefa695411acc0a98d8d
+SHA512:
+  metadata.gz: 7a08a10640fd13c529a64e0a6fc294406fa104930d90a1d13bcb0d4a587c717d343269a7e21d349260735b9a452e1d0e86049c4d93a542777de325cfac142349
+  data.tar.gz: 94ec2894812df92f0732a123b816c254ca75ab2a2b5113cfacf4d228845f3a2b79b18776b016b1a594c51146ec2a30c95ea737070cd7dd648dc1091abbb14e94

data/lib/eldorado.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'httparty'
+require 'nokogiri'
+require 'nokogiri/xml/document_to_hash'
+
+require 'eldorado/error'
+require 'eldorado/client'
+require 'eldorado/builder'
+require 'eldorado/response'
+require 'eldorado/version'

data/lib/eldorado/builder.rb

@@ -0,0 +1,50 @@
+module Eldorado
+  class Builder
+    def initialize(api_key, account_id)
+      @api_key = api_key
+      @account_id = account_id
+    end
+
+    def build(data)
+      doc = Nokogiri::XML::DocumentFragment.parse '<?xml version="1.0" encoding="UTF-8"?>'
+      Nokogiri::XML::Builder.with(doc) do |xml|
+        xml.key(@api_key)
+        xml.accountId(@account_id)
+        data.each_pair do |key, value|
+          xml_pair(xml, key, value)
+        end
+      end
+      doc.to_xml.strip
+    end
+
+    def destruct(data)
+      Nokogiri::XML(data).to_hash
+    end
+
+    private
+    def xml_pair(xml, key, value)
+      key = key.to_sym
+      if value.respond_to? :each_pair
+        xml.send(key) do
+          value.each_pair { |k, v| xml_pair(xml, k, v) }
+        end
+      elsif value.respond_to? :each
+        xml.send(key) do
+          value.each { |val| xml_array(xml, val) }
+        end
+      else
+        xml.send(key.to_sym, value)
+      end
+    end
+
+    def xml_array(xml, value)
+      if value.respond_to? :each_pair
+        value.each_pair { |k, v| xml_pair(xml, k, v) }
+      elsif value.respond_to? :each
+        value.each { |v| v }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/eldorado/client.rb

@@ -0,0 +1,133 @@
+module Eldorado
+  class Client
+    include HTTParty
+    base_uri 'https://eldoradopartner.com'
+
+    attr_accessor :test_mode
+
+    def initialize(api_key, account_id, test_mode = false)
+      login(api_key, account_id)
+      @test_mode = test_mode
+      # if test_mode
+      #   self.class.send(:debug_output, $stderr)
+      # end
+    end
+
+    def ip_address
+      self.class.get('/get_ip/')
+    end
+
+    def stock_check(skus)
+      if skus.is_a?(Array)
+        skus.map do |sku|
+          [sku, singular_stock_check(sku)]
+        end.reject(&:nil?).to_h
+      else
+        { skus => singular_stock_check(skus) }
+      end
+    end
+
+    def discounts
+      response = post('/discounts/', request)
+      if response.discounts
+        response.discounts["item"].map do |item|
+          [item["product_model"], item["discount_percent"].to_i / 100.0]
+        end.to_h
+      end
+    end
+
+    def order_history(source)
+      unless [:website, :api].include?(source)
+        raise Eldorado::Error.new(:order_history_type)
+      end
+      response = post('/order_history/', request(type: source))
+      if response.history
+        if response.history.is_a?(Array)
+          response.history
+        else
+          []
+        end
+      end
+    end
+
+    def open_orders
+      response = post('/open_orders/', request)
+      response.XML_OpenOrders
+    end
+
+    def submit_order(order)
+      endpoint = test_mode ? '/test/orderTest.php' : '/order/index.php'
+      response = post(endpoint, normalize_order(order))
+      response.XML_Orders
+    end
+
+    private
+
+    def normalize_order(order)
+      data = {
+        "Name"                => fetch(order, :name),
+        "AddressLine1"        => fetch(order, :street, :street1, :address1, :addressLine1),
+        "AddressLine2"        => fetch(order, :street2, :address2, :addressLine2),
+        "City"                => fetch(order, :city),
+        "StateCode"           => fetch(order, :state, :stateCode),
+        "ZipCode"             => fetch(order, :zip, :zipCode),
+        "CountryCode"         => fetch(order, :country, :countryCode),
+        "PhoneNumber"         => fetch(order, :phone, :phoneNumber),
+        "EnteredByCode"       => "API",
+        "SourceCode"          => "API",
+        "CustPONumber"        => fetch(order, :custPONumber, :uniqueID, :sourceOrderNumber),
+        "SourceOrderNumber"   => fetch(order, :sourceOrderNumber, :uniqueID),
+        "ShipVia"             => fetch(order, :shipVia, :shipBy, :shipping),
+        "SpecialInstructions" => fetch(order, :specialInstructions, :instructions),
+        "Products"            => (fetch(order, :products, :items) || []).map do |product|
+          {
+            "Product" => {
+              "Code"      => fetch(product, :code, :sku),
+              "Quantity"  => fetch(product, :quantity, :qty, :count)
+            }
+          }
+        end
+      }
+      data.delete_if { |k, v| v.nil? }
+      if test_mode
+        data["SpecialInstructions"] = "TEST ORDER DO NOT PROCESS"
+      end
+      request(data)
+    end
+
+    def post(path, xml)
+      Eldorado::Response.new(self.class.post(path, body: xml))
+    end
+
+    def login(*args)
+      @builder = Eldorado::Builder.new(*args)
+    end
+
+    def request(object = {})
+      @builder.build(object)
+    end
+
+    def singular_stock_check(sku)
+      response = post('/quantitycheck/', request(item: sku))
+      if response.quantity and response.quantity["amount"] != "NOT_FOUND"
+        response.quantity["amount"].to_i
+      else
+        0
+      end
+    end
+
+    def fetch(hash, *keys)
+      keys.each do |key|
+        if hash[key]
+          return hash[key]
+        elsif hash[key.to_s.capitalize.to_sym]
+          return hash[key.to_s.capitalize.to_sym]
+        elsif hash[key.to_s]
+          return hash[key.to_s]
+        elsif hash[key.to_s.capitalize]
+          return hash[key.to_s.capitalize]
+        end
+      end
+    end
+  end
+end

data/lib/eldorado/error.rb

@@ -0,0 +1,16 @@
+module Eldorado
+  class Error < StandardError
+    def initialize(code)
+      @code = code
+      super(message)
+    end
+
+    def message
+      CODES[@code]
+    end
+
+    CODES = {
+      order_history_type: "Order history type must either be :website or :api.",
+    }
+  end
+end

data/lib/eldorado/response.rb

@@ -0,0 +1,49 @@
+require 'ostruct'
+
+module Eldorado
+  class Response
+    attr_accessor :data
+
+    def initialize(data)
+      @data = data.data rescue data
+    end
+
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if method.end_with?('=')
+        data.send(:[]=, method, *args)
+      else
+        response = data.send(:[], method)
+        if response.is_a?(Hash)
+          self.class.new(response)
+        else
+          response
+        end
+      end
+    end
+
+    def self.new_from(http_response, key)
+      new(http_response.parsed_response.try(:[], key))
+    end
+
+    def inspect
+      data.inspect
+    end
+
+    def successful?
+      data.has_key?("Success")
+    end
+
+    def failed?
+      !successful?
+    end
+
+    def log
+      if successful?
+        "[Success] #{data['Success']}"
+      else
+        "[Failure] #{data}"
+      end
+    end
+  end
+end

data/lib/eldorado/version.rb

@@ -0,0 +1,3 @@
+module Eldorado
+  Version = "0.0.0.alpha"
+end

data/lib/nokogiri/xml/document_to_hash.rb

@@ -0,0 +1,22 @@
+module Nokogiri
+  module XML
+    class Document < Nokogiri::XML::Node
+      def to_hash
+        children_to_hash(children)
+      end
+
+      private
+      def children_to_hash(children)
+        hash = {}
+        children.each do |child|
+          if child.children.any?
+            hash[child.name.to_sym] = children_to_hash(child.children)
+          else
+            hash = child.content.to_s
+          end
+        end
+        hash
+      end
+    end
+  end
+end

data/test/eldorado/builder_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class BuilderTest < Minitest::Test
+  def setup
+    @builder = Eldorado::Builder.new("username", "password")
+  end
+
+  # def test_builds_nested_hash_xml
+  #   assert_match_xpath "/hello/there", @builder.build(hello: { there: "buddy" })
+  # end
+
+  # def test_builds_array_xml
+  #   assert_match_xpath "skus/sku", @builder.build(skus: [{sku: 12345}, {sku: 67890}])
+  # end
+
+  def test_breaks_down_xml
+    assert_equal @builder.destruct("<hello><there>buddy</there></hello>"), { hello: { there: "buddy" } }
+  end
+
+  # def test_builds_honey_order
+  #   order = Eldorado::Order.new(reference: "TEST")
+  #   assert_match_xpath "order/reference", @builder.build(order: order)
+  # end
+end

data/test/eldorado/client_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class ClientTest < Minitest::Test
+  def setup
+    api_key = ENV.fetch('PARTNER_KEY', '8bad7f1db3fbcecc366fff3da4101363')
+    account_id = ENV.fetch('PARTNER_ID', '4119F')
+    @client = Eldorado::Client.new(api_key, account_id, true)
+  end
+
+  def test_ip_address
+    assert_equal 4, @client.ip_address.split('.').count
+  end
+
+  def test_discounts
+    sample = @client.discounts.first
+    assert_type String, sample.first
+    assert_type Float, sample.last
+  end
+
+  def test_order_history
+    assert_type Array, @client.order_history(:website)
+    assert_type Array, @client.order_history(:api)
+    assert_raises Eldorado::Error do
+      @client.order_history(:brick_and_mortar)
+    end
+  end
+
+  def test_stock_check
+    assert_type Integer, @client.stock_check('SK2189')
+    multiple = @client.stock_check(['SK2189', 'SK2257'])
+    assert_type Hash, multiple
+    assert_equal 2, multiple.length
+  end
+end

data/test/eldorado/order_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class OrderTest < Minitest::Test
+  def setup
+    @order = Eldorado::Order.new
+  end
+
+  def teardown
+    @order = nil
+  end
+
+  def test_update
+    @order.update(last: "Shreve", items: [:item, :item])
+    assert_equal "Shreve", @order.last
+    assert_equal [:item, :item], @order.items
+  end
+
+  def test_validity
+    assert @order.invalid?
+    @order.required_attributes.each do |attr|
+      @order.send("#{attr}=".to_sym, "hello")
+    end
+    assert @order.valid?
+  end
+
+  def test_present_attributes
+    @order.update(last: "Shreve", first: "Jacob")
+    assert_equal @order.present_attributes, [:last, :first]
+  end
+
+  def test_shipping_options_as_hash
+    @order.shipping = { carrier: :USPS, service: "first class" }
+    assert_equal "P003", @order.shipping
+  end
+
+  def test_shipping_option_from_api_code
+    shipping_option = Eldorado::Order.shipping_option_from_api_code("P003")
+    assert_equal "usps", shipping_option[:carrier]
+    assert_equal "first class", shipping_option[:service]
+  end
+end

data/test/eldorado_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class EldoradoTest < Minitest::Test
+  def test_version_exists
+    assert defined? Eldorado::Version
+  end
+end

data/test/nokogiri/xml/document_to_hash_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class DocumentToHashTest < Minitest::Test
+  def setup
+    @document = Nokogiri::XML("<hello><there>buddy</there></hello")
+  end
+
+  def test_document_to_hash
+    assert_equal @document.to_hash, { hello: { there: "buddy" } }
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..','lib'))
+require 'Eldorado'
+
+def valid_order
+  Eldorado::Order.new({
+    items: [
+      { item: { sku: 1234, qty: 1 } },
+      { item: { sku: 5678, qty: 1 } }
+    ],
+    last: "Shreve",
+    first: "Jacob",
+    address1: "1234 East St.",
+    city: "Fowlerville",
+    state: "MI",
+    zip: 48836,
+    country: "US",
+    phone: "(123) 456-7890",
+    emailaddress: "jacob@example.com",
+    instructions: "Leave the package behind the wooden bear"
+  })
+end
+
+def assert_type(expected, instance)
+  assert instance.is_a?(expected), "Expected to find instance of #{expected.name}. Instead found #{instance.class.name} #{instance}"
+end
+
+def assert_match_xpath(expected, actual, message = nil)
+  expected = "#{expected}"
+  doc = Nokogiri::XML(actual)
+  nodes = doc.xpath(expected)
+  assert !nodes.empty?, message || "Expected to find xpath #{expected} in response:\n#{actual}"
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: eldorado
+version: !ruby/object:Gem::Version
+  version: 0.0.0.alpha
+platform: ruby
+authors:
+- Jacob Evan Shreve
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.1
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: |2
+      Eldorado is a wrapper for the Eldorado.net API which easily enables
+      placing orders, checking order statuses, and stock checking.
+email: jacob@sugutoys.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/eldorado.rb
+- lib/eldorado/builder.rb
+- lib/eldorado/client.rb
+- lib/eldorado/error.rb
+- lib/eldorado/response.rb
+- lib/eldorado/version.rb
+- lib/nokogiri/xml/document_to_hash.rb
+- test/eldorado/builder_test.rb
+- test/eldorado/client_test.rb
+- test/eldorado/order_test.rb
+- test/eldorado_test.rb
+- test/nokogiri/xml/document_to_hash_test.rb
+- test/test_helper.rb
+homepage: http://github.com/SuguToys/eldorado
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A wrapper for the Eldorado.net API
+test_files:
+- test/eldorado/builder_test.rb
+- test/eldorado/client_test.rb
+- test/eldorado/order_test.rb
+- test/eldorado_test.rb
+- test/nokogiri/xml/document_to_hash_test.rb
+- test/test_helper.rb