walmart_open 0.0.1

data/lib/walmart_open/order.rb

@@ -0,0 +1,53 @@
+require "walmart_open/order_item"
+require "walmart_open/item"
+require "walmart_open/shipping_address"
+require "securerandom"
+
+module WalmartOpen
+  class Order
+
+    attr_reader :shipping_address
+    attr_accessor :billing_id, :first_name, :last_name, :partner_order_time,
+                  :partner_order_id, :phone, :items
+
+    def initialize(params)
+      @shipping_address = nil
+      @items = []
+      @billing_id = params[:billing_id]
+      @first_name = params[:first_name]
+      @last_name = params[:last_name]
+      @phone = params[:phone]
+      @partner_order_id = params[:partner_order_id] || "Order-#{Digest::SHA1.hexdigest("#{Time.now.to_i}:#{SecureRandom.hex(16)}")[0..19].upcase}"
+      @partner_order_time = params[:partner_order_time] || Time.now
+    end
+
+    def add_shipping_address(params)
+      @shipping_address = ShippingAddress.new(params)
+    end
+
+    def add_item(item_or_item_id, *args)
+      if item_or_item_id.is_a?(Item)
+        # add_item(item, quantity = 1)
+        @items << OrderItem.new(item_or_item_id.id, item_or_item_id.price, item_or_item_id.shipping_rate, args[0] || 1)
+      else
+        # add_item(item_id, item_price, shipping_price = 0, quantity = 1)
+        @items <<  OrderItem.new(item_or_item_id, args[0], args[1] || 0, args[2] || 1)
+      end
+    end
+
+    def valid?
+      base_values_valid? && !shipping_address.nil? && shipping_address.valid? && items_valid?
+    end
+
+    private
+
+    def base_values_valid?
+      billing_id && first_name && partner_order_time && partner_order_id
+    end
+
+    def items_valid?
+      items.any? && items.all?(&:valid?)
+    end
+
+  end
+end

data/lib/walmart_open/order_item.rb

@@ -0,0 +1,17 @@
+module WalmartOpen
+  class OrderItem
+
+    attr_accessor :item_id, :quantity, :item_price, :shipping_price
+
+    def initialize(item_id, item_price, shipping_price = 0, quantity = 1)
+      @item_id = item_id
+      @quantity = quantity
+      @item_price = item_price
+      @shipping_price = shipping_price
+    end
+
+    def valid?
+      !!(item_id && quantity && item_price && shipping_price)
+    end
+  end
+end

data/lib/walmart_open/order_results.rb

@@ -0,0 +1,40 @@
+require "walmart_open/ordered_item"
+
+module WalmartOpen
+  class OrderResults
+    attr_reader :error, :order_id, :partner_order_id, :items, :total, :shipping, :sales_tax, :surcharge, :raw_attributes
+
+    def initialize(attrs)
+      @raw_attributes = attrs
+
+      if attrs["errors"] && attrs["errors"]["error"]
+        @error = {code: attrs["errors"]["error"]["code"], message: attrs["errors"]["error"]["message"]}
+      else
+        response = attrs["response"]
+        @order_id = response["orderId"]
+        @partner_order_id = response["partnerOrderId"]
+        @total = response["itemTotal"]
+        @shipping = response["shipping"]
+        @sales_tax = response["salesTax"]
+        @surcharge = response["surcharge"]
+
+        @items = []
+        if response["items"] && response["items"]["item"]
+          if response["items"]["item"].is_a?(Array)
+            items = response["items"]["item"]
+          else
+            items = [response["items"]["item"]]
+          end
+          items.each do | item |
+            @items << OrderedItem.new(item)
+          end
+        end
+      end
+    end
+
+    def error?
+      !@error.nil?
+    end
+  end
+
+end

data/lib/walmart_open/order_xml_builder.rb

@@ -0,0 +1,62 @@
+require "builder"
+
+module WalmartOpen
+  class OrderXMLBuilder
+    attr_reader :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    def build
+      xml = Builder::XmlMarkup.new
+      xml.instruct!(:xml, version: "1.0", encoding: "UTF-8")
+      xml.order do |xml|
+        payment(xml)
+        shipping_address(xml)
+        xml.partnerOrderId(order.partner_order_id)
+        xml.partnerOrderTime(order.partner_order_time.strftime( "%H:%M:%S"))
+
+        xml.items do |xml|
+          order.items.each do |order_item|
+            item(xml, order_item)
+          end
+        end
+
+        xml.target!
+      end
+
+    end
+
+    private
+
+    def shipping_address(xml)
+      xml.shippingAddress do |xml|
+        xml.firstName(order.first_name)
+        xml.lastName(order.last_name)
+        xml.street1(order.shipping_address.street1)
+        xml.street2(order.shipping_address.street2) if order.shipping_address.street2
+        xml.city(order.shipping_address.city)
+        xml.state(order.shipping_address.state)
+        xml.zip(order.shipping_address.zipcode)
+        xml.country(order.shipping_address.country)
+        xml.phone(order.phone) if order.phone
+      end
+    end
+
+    def payment(xml)
+      xml.payment do |xml|
+        xml.billingRecordId(order.billing_id)
+      end
+    end
+
+    def item(xml, order_item)
+      xml.item do |xml|
+        xml.itemId(order_item.item_id)
+        xml.quantity(order_item.quantity)
+        xml.itemPrice(order_item.item_price)
+        xml.shippingPrice(order_item.shipping_price)
+      end
+    end
+  end
+end

data/lib/walmart_open/ordered_item.rb

@@ -0,0 +1,31 @@
+module WalmartOpen
+  class OrderedItem
+    API_ATTRIBUTES_MAPPING = {
+      "itemId" => "id",
+      "quantity" => "quantity",
+      "itemPrice" => "price"
+    }
+
+    API_ATTRIBUTES_MAPPING.each_value do |attr_name|
+      attr_reader attr_name
+    end
+
+    attr_reader :raw_attributes
+
+    def initialize(attrs)
+      @raw_attributes = attrs
+
+      extract_known_attributes
+    end
+
+    private
+
+    def extract_known_attributes
+      API_ATTRIBUTES_MAPPING.each do |api_attr, attr|
+        next unless raw_attributes.has_key?(api_attr)
+
+        instance_variable_set("@#{attr}", raw_attributes[api_attr])
+      end
+    end
+  end
+end

data/lib/walmart_open/product_request.rb

@@ -0,0 +1,28 @@
+require "walmart_open/request"
+
+module WalmartOpen
+  class ProductRequest < Request
+    private
+
+    def build_url(client)
+      url = "https://#{client.config.product_domain}"
+      url << "/#{client.config.product_version}"
+      url << "/#{path}"
+      url << params_to_query_string(build_params(client))
+    end
+
+    def build_params(client)
+      {
+        format: "json",
+        api_key: client.config.product_api_key
+      }.merge(params || {})
+    end
+
+    # Walmart API unofficially supports HTTPS so we rather hit that instead of
+    # HTTP. However, their SSL certificate is unverifiable so we have to tell
+    # HTTParty not to verify (otherwise it will complain).
+    def request_options(client)
+      { verify: false }
+    end
+  end
+end

data/lib/walmart_open/request.rb

@@ -0,0 +1,64 @@
+require "httparty"
+require "uri"
+require "walmart_open/errors"
+
+module WalmartOpen
+  class Request
+    attr_reader :path, :params
+
+    def submit(client)
+      raise "@path must be specified" unless path
+
+      response = HTTParty.public_send(request_method, build_url(client), request_options(client))
+      verify_response(response)
+      parse_response(response)
+    end
+
+    private
+
+    attr_writer :path, :params
+
+    def request_method
+      :get
+    end
+
+    def build_url(client)
+      raise NotImplementedError, "build_url must be implemented by subclass"
+    end
+
+    def build_params(client)
+      # noop
+    end
+
+    def request_options(client)
+      {}
+    end
+
+    # Subclasses can override this method to return a different response.
+    def parse_response(response)
+      response
+    end
+
+    def verify_response(response)
+      unless response.success?
+        raise WalmartOpen::AuthenticationError, response.parsed_response.inspect
+      end
+    end
+
+    def params_to_query_string(params_hash)
+      params_hash = convert_param_keys(params_hash || {})
+      query_str = URI.encode_www_form(params_hash)
+      query_str.prepend("?") unless query_str.size.zero?
+      query_str
+    end
+
+    # Converts foo_bar_param to fooBarParam.
+    def convert_param_keys(underscored_params)
+      pairs = underscored_params.map do |key, value|
+        key = key.to_s.gsub(/_([a-z])/i) { $1.upcase }
+        [key, value]
+      end
+      Hash[pairs]
+    end
+  end
+end

data/lib/walmart_open/requests/lookup.rb

@@ -0,0 +1,27 @@
+require "walmart_open/product_request"
+require "walmart_open/item"
+require "walmart_open/errors"
+
+module WalmartOpen
+  module Requests
+    class Lookup < ProductRequest
+      def initialize(item_id, params = {})
+        self.path = "items/#{item_id}"
+        self.params = params
+      end
+
+      private
+
+      def parse_response(response)
+        Item.new(response.parsed_response)
+      end
+
+      def verify_response(response)
+        if response.code == 400
+          raise WalmartOpen::ItemNotFoundError, response.parsed_response.inspect
+        end
+        super
+      end
+    end
+  end
+end

data/lib/walmart_open/requests/place_order.rb

@@ -0,0 +1,58 @@
+require "walmart_open/commerce_request"
+require "walmart_open/order_xml_builder"
+require "walmart_open/order_results"
+require "walmart_open/errors"
+require "openssl"
+require "base64"
+
+
+module WalmartOpen
+  module Requests
+    class PlaceOrder < CommerceRequest
+      attr_accessor :order
+
+      def initialize(order)
+        self.path = "orders/place"
+        @order = order
+      end
+
+      private
+
+      def parse_response(response)
+        OrderResults.new(response.parsed_response)
+      end
+
+      def verify_response(response)
+        if response.code == 400
+          raise WalmartOpen::OrderError, response.parsed_response.inspect
+        end
+        super
+      end
+
+      def request_options(client)
+        body = build_xsd
+        signature = client.config.debug ? "FAKE_SIGNATURE" : sign(client.config.private_key, body)
+        {
+          headers: {
+            "Authorization" => client.auth_token.authorization_header,
+            "Content-Type" => "text/xml",
+            "X-Walmart-Body-Signature" => signature
+          },
+          body: body
+        }
+      end
+
+      def build_params(client)
+        { disablesigv: true } if client.config.debug
+      end
+
+      def build_xsd
+        OrderXMLBuilder.new(order).build
+      end
+
+      def sign(key, data)
+        Base64.urlsafe_encode64(key.sign(OpenSSL::Digest::SHA256.new, data))
+      end
+    end
+  end
+end

data/lib/walmart_open/requests/search.rb

@@ -0,0 +1,19 @@
+require "walmart_open/product_request"
+require "walmart_open/search_results"
+
+module WalmartOpen
+  module Requests
+    class Search < ProductRequest
+      def initialize(query, params = {})
+        self.path = "search"
+        self.params = params.merge(query: query)
+      end
+
+      private
+
+      def parse_response(response)
+        SearchResults.new(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/walmart_open/requests/taxonomy.rb

@@ -0,0 +1,17 @@
+require "walmart_open/product_request"
+
+module WalmartOpen
+  module Requests
+    class Taxonomy < ProductRequest
+      def initialize
+        self.path = "taxonomy"
+      end
+
+      private
+
+      def parse_response(response)
+        response.parsed_response["categories"]
+      end
+    end
+  end
+end

data/lib/walmart_open/requests/token.rb

@@ -0,0 +1,30 @@
+require "walmart_open/commerce_request"
+require "walmart_open/auth_token"
+
+module WalmartOpen
+  module Requests
+    class Token < CommerceRequest
+      def initialize
+        self.path = "oauth2/token"
+      end
+
+      private
+
+      def request_options(client)
+        {
+          basic_auth: {
+            username: client.config.commerce_api_key,
+            password: client.config.commerce_api_secret
+          },
+          body: {
+            grant_type: "client_credentials"
+          }
+        }
+      end
+
+      def parse_response(response)
+        AuthToken.new(response.parsed_response, Time.parse(response.headers["date"]))
+      end
+    end
+  end
+end