walmart_open 0.0.8 → 0.1.0

data/lib/walmart_open/auth_token.rb

@@ -1,25 +0,0 @@
-module WalmartOpen
-  class AuthToken
-    BUFFER_TIME = 30 # seconds
-
-    attr_reader :token_type,
-                :access_token,
-                :time,
-                :expiration_time
-
-    def initialize(attrs, grant_time = Time.now)
-      @expiration_time = grant_time + attrs["expires_in"]
-      @token_type = attrs["token_type"]
-      @access_token = attrs["access_token"]
-      @time = grant_time
-    end
-
-    def expired?
-      Time.now + BUFFER_TIME >= expiration_time
-    end
-
-    def authorization_header
-      "#{token_type.capitalize} #{access_token}"
-    end
-  end
-end

data/lib/walmart_open/commerce_request.rb

@@ -1,23 +0,0 @@
-require "walmart_open/request"
-
-module WalmartOpen
-  class CommerceRequest < Request
-    private
-
-    def request_method
-      :post
-    end
-
-    def build_url(client)
-      url = "https://#{client.config.commerce_domain}"
-      url << "/#{client.config.commerce_version}"
-      url << "/qa" if client.config.debug
-      url << "/#{path}"
-      url << params_to_query_string(build_params(client))
-    end
-
-    def parse_response(response)
-      OrderResults.new(response.parsed_response)
-    end
-  end
-end

data/lib/walmart_open/order.rb

@@ -1,55 +0,0 @@
-require "walmart_open/order_item"
-require "walmart_open/item"
-require "walmart_open/shipping_address"
-require "securerandom"
-
-module WalmartOpen
-  class Order
-
-    attr_reader :shipping_address, :items
-    attr_accessor :billing_record_id, :partner_order_time, :partner_order_id
-
-    def initialize(params)
-      params = params.each_with_object({}) do |pair, obj|
-        obj[pair.first.to_sym] = pair.last
-      end
-
-      @shipping_address = nil
-      @items = []
-      @billing_record_id = params[:billing_record_id]
-      @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
-      @shipping_address = add_shipping_address(params)
-    end
-
-    def add_item(item_or_item_id, quantity = 1, *args)
-      if item_or_item_id.is_a?(Item)
-        # add_item(item, quantity = 1)
-        @items << OrderItem.new(item_or_item_id.id, quantity, item_or_item_id.price, item_or_item_id.shipping_rate)
-      else
-        # add_item(item_id, quantity = 1, item_price = nil, shipping_price = nil)
-        @items <<  OrderItem.new(item_or_item_id, quantity, args[0], args[1])
-      end
-    end
-
-    def valid?
-      base_values_valid? && items_valid? &&
-        shipping_address && shipping_address.valid?
-    end
-
-    private
-
-    def add_shipping_address(params)
-      ShippingAddress.new(params)
-    end
-
-    def base_values_valid?
-      !!(billing_record_id && 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

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

data/lib/walmart_open/order_results.rb

@@ -1,40 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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.shipping_address.first_name)
-        xml.lastName(order.shipping_address.last_name) if order.shipping_address.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.shipping_address.phone)
-      end
-    end
-
-    def payment(xml)
-      xml.payment do |xml|
-        xml.billingRecordId(order.billing_record_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) if order_item.item_price
-        xml.shippingPrice(order_item.shipping_price) if order_item.shipping_price
-      end
-    end
-  end
-end

data/lib/walmart_open/ordered_item.rb

@@ -1,31 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/requests/place_order.rb

@@ -1,58 +0,0 @@
-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/token.rb

@@ -1,30 +0,0 @@
-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

data/lib/walmart_open/shipping_address.rb

@@ -1,46 +0,0 @@
-module WalmartOpen
-  class ShippingAddress
-    REQUIRED_ATTRIBUTES = [
-      :first_name,
-      :street1,
-      :city,
-      :state,
-      :zipcode,
-      :country,
-      :phone
-    ]
-
-    OPTIONAL_ATTRIBUTES = [
-      :last_name,
-      :street2,
-    ]
-
-    ATTRIBUTES = REQUIRED_ATTRIBUTES + OPTIONAL_ATTRIBUTES
-
-    attr_reader *ATTRIBUTES
-
-    def initialize(params)
-      params = params.each_with_object({}) do |pair, obj|
-        obj[pair.first.to_sym] = pair.last
-      end
-
-      set_attributes(params)
-    end
-
-    def valid?
-      REQUIRED_ATTRIBUTES.map do |attr|
-        public_send(attr).to_s.empty?
-      end.none?
-    end
-
-    private
-
-    def set_attributes(attrs)
-      ATTRIBUTES.each do |attr|
-        next unless attrs.include?(attr)
-
-        instance_variable_set("@#{attr}", attrs[attr])
-      end
-    end
-  end
-end

data/spec/walmart_open/auth_token_spec.rb

@@ -1,53 +0,0 @@
-require "spec_helper"
-require "walmart_open/auth_token"
-require "timecop"
-
-describe WalmartOpen::AuthToken do
-  let(:auth_token_attrs) do
-    {
-      "token_type"    =>  "bearer",
-      "mapi"          =>  "8tbvkxd6gu6zjzp6qbyeewb6",
-      "access_token"  =>  "k5pzg6jqtetygmrkm5y6qqnr",
-      "expires_in"    =>  600
-    }
-  end
-
-  let(:auth_token) do
-    WalmartOpen::AuthToken.new(auth_token_attrs, Time.now)
-  end
-
-  context ".new" do
-    it "initializes with attributes" do
-      Timecop.freeze(Time.now) do
-        expect(auth_token.expiration_time).to eq(Time.now + auth_token_attrs["expires_in"])
-        expect(auth_token.token_type).to eq(auth_token_attrs["token_type"])
-        expect(auth_token.access_token).to eq(auth_token_attrs["access_token"])
-        expect(auth_token.time).to eq(Time.now)
-      end
-    end
-  end
-
-  context "#expired?" do
-    it "returns true when auth token has expired" do
-      Timecop.freeze(Time.now) do
-        auth_token
-
-        Timecop.freeze(Time.now + auth_token_attrs["expires_in"] + WalmartOpen::AuthToken::BUFFER_TIME) do
-          expect(auth_token).to be_expired
-        end
-      end
-    end
-
-    it "returns false when auth token has not expired" do
-      Timecop.freeze(Time.now) do
-        expect(auth_token).not_to be_expired
-      end
-    end
-  end
-
-  context "#authorization_header" do
-    it "returns authentication_header" do
-      expect(auth_token.authorization_header).to eq("Bearer k5pzg6jqtetygmrkm5y6qqnr")
-    end
-  end
-end