lipseys 5.0.1 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 823c554eff146611688ad459e698e449625640f8
-  data.tar.gz: 96a39a440393b8bebcb8a4b7872aeaf6a0cf893b
+  metadata.gz: 4403d00b0a7ca5e2b6754e739d85bae695e8c6ce
+  data.tar.gz: c8e997c51bc28411ea030341b77591a20e6f9b58
 SHA512:
-  metadata.gz: 7a02161b0af4d5dc95f45b9f0a677b5ff7379ad20c5a59b5fd02ae5101adfa7c0b715d986eded166b27fc24e8a34f0c7c3f6e68da468f10aeb93755b77d40e10
-  data.tar.gz: c1592da12a360a88b85daef78e24ddec07858a1e3688e12b7d30cd7dfc6873281b5dce54cadbcf490bd65287115053bab4ce1ab9b348e9af8c032ed02866f54f
+  metadata.gz: e5c1ad6a782c66656e2dafe7f4dedc0fecf2232e0c5425319d7b5ac0a775633ab4a9dcb4f9f7461a29407e713492e3c977fdf58ffabc4f46ad9649e02dbf2dd7
+  data.tar.gz: 5589846a2cbbee7b70eaa57831b42d385a09ba42950d1205162c42bb033070abadcb880b4d96daaf3821cb47154abe9c45c131ddc2fff2a30643774d2b5173fa

data/lib/lipseys.rb

@@ -1,20 +1,38 @@
-require 'lipseys/version'
-
-require 'net/http'
-require 'nokogiri'
-require 'savon'
-
 require 'lipseys/base'
-require 'lipseys/soap_client'
+require 'lipseys/version'
 
+require 'lipseys/api'
 require 'lipseys/catalog'
+require 'lipseys/client'
+require 'lipseys/error'
 require 'lipseys/inventory'
-require 'lipseys/invoice'
+require 'lipseys/items'
 require 'lipseys/order'
+require 'lipseys/response'
 require 'lipseys/user'
-require 'lipseys/image'
-require 'lipseys/parser'
 
 module Lipseys
-  class NotAuthenticated < StandardError; end
+
+  class << self
+    attr_accessor :config
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+
+  class Configuration
+    attr_accessor :proxy_address
+    attr_accessor :proxy_port
+
+    def initialize
+      @proxy_address ||= nil
+      @proxy_port    ||= nil
+    end
+  end
+
 end

data/lib/lipseys/api.rb

@@ -0,0 +1,121 @@
+require 'net/http'
+
+module Lipseys
+  module API
+
+    ROOT_API_URL = 'https://api.lipseys.com/api/integration'.freeze
+    USER_AGENT = "LipseysRubyGem/#{Lipseys::VERSION}".freeze
+
+    FILE_UPLOAD_ATTRS = {
+      permitted: %i( file_name file_type file_contents ).freeze,
+      reqired:   %i( file_type file_contents ).freeze,
+    }
+
+    def get_request(endpoint, headers = {})
+      request = Net::HTTP::Get.new(request_url(endpoint))
+
+      submit_request(request, {}, headers)
+    end
+
+    def post_request(endpoint, data = {}, headers = {})
+      request = Net::HTTP::Post.new(request_url(endpoint))
+
+      submit_request(request, data, headers)
+    end
+
+    def post_file_request(endpoint, file_data, headers = {})
+      request = Net::HTTP::Post.new(request_url(endpoint))
+
+      submit_file_request(request, file_data, headers)
+    end
+
+    private
+
+    def submit_request(request, data, headers)
+      set_request_headers(request, headers)
+
+      request.body = data.is_a?(Hash) ? data.to_json : data
+
+      process_request(request)
+    end
+
+    def submit_file_request(request, file_data, headers)
+      boundary = ::SecureRandom.hex(15)
+
+      headers.merge!(content_type_header("multipart/form-data; boundary=#{boundary}"))
+
+      build_multipart_request_body(request, file_data, boundary)
+      set_request_headers(request, headers)
+      process_request(request)
+    end
+
+    def process_request(request)
+      uri = URI(request.path)
+
+      response = Net::HTTP.start(uri.host, uri.port, Lipseys.config.proxy_address, Lipseys.config.proxy_port, use_ssl: true) do |http|
+        http.request(request)
+      end
+
+      Lipseys::Response.new(response)
+    end
+
+    def build_multipart_request_body(request, file_data, boundary)
+      file_type     = file_data[:file_type]
+      file_contents = file_data[:file_contents]
+      file_name     = file_data[:file_name] || "ffl-document.#{file_type}"
+      content_type  = "application/#{file_data[:file_type]}"
+
+      body = []
+      body << "--#{boundary}\r\n"
+      body << "Content-Disposition: form-data; name=\"file\"; filename=\"#{file_name}\"\r\n"
+      body << "Content-Type: #{content_type}\r\n"
+      body << "\r\n"
+      body << "#{file_contents}\r\n"
+      body << "--#{boundary}--\r\n"
+
+      request.body = body.join
+    end
+
+    def set_request_headers(request, headers)
+      request['User-Agent'] = USER_AGENT
+
+      headers.each { |header, value| request[header] = value }
+    end
+
+    def auth_header(token)
+      { 'Token' => token }
+    end
+
+    def content_type_header(type)
+      { 'Content-Type' => type }
+    end
+
+    def request_url(endpoint)
+      [ROOT_API_URL, endpoint].join('/')
+    end
+
+    def standardize_body_data(submitted_data, permitted_data_attrs)
+      _submitted_data = submitted_data.deep_transform_keys(&:to_sym)
+      permitted_data = {}
+
+      _submitted_data.each do |k1, v1|
+        if permitted_data_attrs.include?(k1)
+          if v1.is_a?(Array)
+            permitted_data[k1] = []
+
+            v1.each do |sub_data|
+              permitted_sub_data = {}
+              sub_data.each { |k2, v2| permitted_sub_data[k2] = v2 if permitted_data_attrs.include?(k2) }
+              permitted_data[k1] << permitted_sub_data
+            end
+          else
+            permitted_data[k1] = v1
+          end
+        end
+      end
+
+      permitted_data.deep_transform_keys { |k| k.to_s.camelize(:lower) }
+    end
+
+  end
+end

data/lib/lipseys/base.rb

@@ -3,70 +3,24 @@ module Lipseys
 
     protected
 
-    # Wrapper to `self.requires!` that can be used as an instance method.
     def requires!(*args)
       self.class.requires!(*args)
     end
 
     def self.requires!(hash, *params)
+      hash_keys = hash.collect { |k, v| v.is_a?(Array) ? [k, v.collect(&:keys)] : k }.flatten
+
       params.each do |param|
         if param.is_a?(Array)
-          raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first)
+          raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash_keys.include?(param.first)
 
           valid_options = param[1..-1]
           raise ArgumentError.new("Parameter: #{param.first} must be one of: #{valid_options.join(', ')}") unless valid_options.include?(hash[param.first])
         else
-          raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param)
+          raise ArgumentError.new("Missing required parameter: #{param}") unless hash_keys.include?(param)
         end
       end
     end
 
-    def content_for(xml_doc, field)
-      node = xml_doc.css(field).first
-      node.nil? ? nil : node.content.strip
-    end
-
-    def get_response_xml(api_url, params)
-      uri = URI(api_url)
-      uri.query = URI.encode_www_form(params_to_auth(params))
-
-      response = Net::HTTP.get_response(uri)
-      xml_doc = Nokogiri::XML(response.body)
-
-      raise Lipseys::NotAuthenticated if not_authenticated?(xml_doc)
-
-      xml_doc
-    end
-
-    def not_authenticated?(xml_doc)
-      msg = content_for(xml_doc, 'CatalogError')
-      msg =~ /Login failed/i || msg =~ /Credentials Not Valid/i
-    end
-
-    def stream_to_tempfile(api_url, params)
-      tempfile  = Tempfile.new
-      uri       = URI(api_url)
-      uri.query = URI.encode_www_form(params_to_auth(params))
-
-      Net::HTTP.get_response(uri) do |response|
-        File.open(tempfile, 'w') do |file|
-          response.read_body do |chunk|
-            file.write(chunk.force_encoding('UTF-8'))
-          end
-        end
-      end
-
-      tempfile
-    end
-
-    private
-
-    def params_to_auth(params)
-      {
-        email: params.fetch(:username),
-        pass: params.fetch(:password),
-      }
-    end
-
   end
 end

data/lib/lipseys/catalog.rb

@@ -1,87 +1,64 @@
 module Lipseys
   class Catalog < Base
 
-    CHUNK_SIZE = 500
-    API_URL    = 'http://184.188.80.195/API/catalog.ashx'
-    ITEMTYPES  = %w(ACCESSORY FIREARM NFA OPTIC)
-
     def initialize(options = {})
       requires!(options, :username, :password)
 
-      @options = options
+      @client = Lipseys::Client.new(username: options[:username], password: options[:password])
     end
 
     def self.all(options = {})
       requires!(options, :username, :password)
+
       new(options).all
     end
 
     def all
-      inventory_tempfile = stream_to_tempfile(Lipseys::Inventory::API_URL, @options)
-      catalog_tempfile   = stream_to_tempfile(API_URL, @options)
-      inventory          = []
-      items              = []
-
-      # Let's get the inventory and toss 'er into an array
-      Lipseys::Parser.parse(inventory_tempfile, 'Item') do |node|
-        inventory.push({
-          item_identifier: content_for(node, 'ItemNo'),
-          map_price: content_for(node, 'RetailMAP'),
-          quantity: content_for(node, 'QtyOnHand'),
-          price: content_for(node, 'Price')
-        })
-      end
-
-      Lipseys::Parser.parse(catalog_tempfile, 'Item') do |node|
-        item = map_hash(node)
-        availability = inventory.select { |i| i[:item_identifier] == item[:item_identifier] }.first
-
-        if availability
-          item[:price]     = availability[:price]
-          item[:quantity]  = availability[:quantity]
-          item[:map_price] = availability[:map_price]
-        end
-
-        items << item
-      end
-
-      inventory_tempfile.unlink
-      catalog_tempfile.unlink
-
-      items
+      @client.items.catalog_feed[:data].map { |item| map_hash(item) }
     end
 
     private
 
-    def map_hash(node)
-      model      = content_for(node, 'Model')
-      mfg_number = content_for(node, 'MFGModelNo')
-      name       = "#{model} #{mfg_number}".lstrip.rstrip
-
+    def map_hash(item)
       {
-        name: name,
-        model: model,
-        upc: content_for(node, 'UPC'),
-        short_description: content_for(node, 'Desc2'),
-        category: content_for(node, 'Type'),
-        price: nil,
-        weight: content_for(node, 'Weight'),
-        item_identifier: content_for(node, 'ItemNo'),
-        brand: content_for(node, 'MFG'),
-        mfg_number: mfg_number,
+        name: [item[:model].try(:strip), item[:manufacturerModelNo].try(:strip)].compact.join(' '),
+        model: item[:model],
+        upc: item[:upc],
+        long_description: item[:description1],
+        short_description: item[:description2],
+        category: item[:type],
+        price: item[:price],
+        map_price: item[:retailMap],
+        msrp: item[:msrp],
+        quantity: item[:quantity],
+        weight: item[:weight],
+        item_identifier: item[:itemNo],
+        brand: item[:manufacturer],
+        mfg_number: item[:manufacturerModelNo],
         features: {
-          caliber:  content_for(node, 'Caliber'),
-          action:   content_for(node, 'Action'),
-          barrel:   content_for(node, 'Barrel'),
-          capacity: content_for(node, 'Capacity'),
-          finish:   content_for(node, 'Finish'),
-          length:   content_for(node, 'Length'),
-          receiver: content_for(node, 'Receiver'),
-          safety:   content_for(node, 'Safety'),
-          sights:   content_for(node, 'Sights'),
-          magazine: content_for(node, 'Magazine'),
-          chamber:  content_for(node, 'Chamber')
-        }
+          caliber: item[:caliberGauge],
+          action: item[:action],
+          barrel: item[:barrelLength],
+          capacity: item[:capacity],
+          finish: item[:finish],
+          length: item[:overallLength],
+          receiver: item[:receiver],
+          safety: item[:safety],
+          sights: item[:sights],
+          stock_frame_grips: item[:stockFrameGrips],
+          magazine: item[:magazine],
+          chamber: item[:chamber],
+          rate_of_twist: item[:rateOfTwist],
+          additional_feature_1: item[:additionalFeature1],
+          additional_feature_2: item[:additionalFeature2],
+          additional_feature_3: item[:additionalFeature3],
+          nfa_thread_pattern: item[:nfaThreadPattern],
+          nfa_attachment_method: item[:nfaAttachmentMethod],
+          nfa_baffle_type: item[:nfaBaffleType],
+          nfa_db_reduction: item[:nfaDbReduction],
+          nfa_form_3_caliber: item[:nfaForm3Caliber],
+          optic_magnification: item[:opticMagnification],
+        },
       }
     end
 

data/lib/lipseys/client.rb

@@ -0,0 +1,40 @@
+require 'lipseys/api'
+require 'lipseys/items'
+require 'lipseys/order'
+
+module Lipseys
+  class Client < Base
+
+    include Lipseys::API
+
+    attr_accessor :access_token
+
+    def initialize(options = {})
+      requires!(options, :username, :password)
+      @options = options
+
+      authenticate!
+    end
+
+    def items
+      @items ||= Lipseys::Items.new(self)
+    end
+
+    def order
+      @order ||= Lipseys::Order.new(self)
+    end
+
+    private
+
+    def authenticate!
+      response = post_request(
+        'authentication/login',
+        { email: @options[:username], password: @options[:password] },
+        content_type_header('application/json')
+      )
+
+      self.access_token = response[:token]
+    end
+
+  end
+end

data/lib/lipseys/error.rb

@@ -0,0 +1,11 @@
+module Lipseys
+  class Error < StandardError
+
+    class NoContent < Lipseys::Error; end
+    class NotAuthorized < Lipseys::Error; end
+    class NotFound < Lipseys::Error; end
+    class RequestError < Lipseys::Error; end
+    class TimeoutError < Lipseys::Error; end
+
+  end
+end

data/lib/lipseys/inventory.rb

@@ -1,62 +1,30 @@
 module Lipseys
   class Inventory < Base
 
-    API_URL = 'http://184.188.80.195/API/pricequantitycatalog.ashx'
-
     def initialize(options = {})
       requires!(options, :username, :password)
 
-      @options = options
+      @client = Lipseys::Client.new(username: options[:username], password: options[:password])
     end
 
     def self.all(options = {})
-      new(options).all
-    end
+      requires!(options, :username, :password)
 
-    def self.quantity(options = {})
       new(options).all
     end
-
-    def self.get_quantity_file(options = {})
-      new(options).get_quantity_file
-    end
+    class << self; alias_method :quantity, :all; end
 
     def all
-      items    = []
-      tempfile = stream_to_tempfile(API_URL, @options)
-
-      Lipseys::Parser.parse(tempfile, 'Item') do |node|
-        _map_hash = map_hash(node)
-
-        items << _map_hash unless _map_hash.nil?
-      end
-
-      tempfile.unlink
-
-      items
-    end
-
-    def get_quantity_file
-      quantity_tempfile = stream_to_tempfile(API_URL, @options)
-      tempfile          = Tempfile.new
-
-      Lipseys::Parser.parse(quantity_tempfile, 'Item') do |node|
-        tempfile.puts("#{content_for(node, 'ItemNo')},#{content_for(node, 'QtyOnHand')}")
-      end
-
-      quantity_tempfile.unlink
-      tempfile.close
-
-      tempfile.path
+      @client.items.pricing_quantity_feed[:data][:items].map { |item| map_hash(item) }
     end
 
     private
 
-    def map_hash(node)
+    def map_hash(item)
       {
-        item_identifier: content_for(node, 'ItemNo'),
-        quantity: content_for(node, 'QtyOnHand'),
-        price: content_for(node, 'Price')
+        item_identifier: item[:itemNumber],
+        quantity: item[:quantity],
+        price: item[:price],
       }
     end
 

data/lib/lipseys/items.rb

@@ -0,0 +1,54 @@
+require 'lipseys/api'
+
+module Lipseys
+  class Items < Base
+
+    include Lipseys::API
+
+    ENDPOINTS = {
+      catalog_feed:          "items/catalogfeed".freeze,
+      pricing_quantity_feed: "items/pricingquantityfeed".freeze,
+      validate_item:         "items/validateitem".freeze,
+      catalog_feed_item:     "items/catalogfeed/item".freeze,
+    }
+
+    def initialize(client)
+      @client = client
+    end
+
+    def catalog_feed
+      endpoint = ENDPOINTS[:catalog_feed]
+
+      get_request(endpoint, auth_header(@client.access_token))
+    end
+
+    def pricing_quantity_feed
+      endpoint = ENDPOINTS[:pricing_quantity_feed]
+
+      get_request(endpoint, auth_header(@client.access_token))
+    end
+
+    # `identifier` can be Item #, Mfg Model #, or UPC
+    def validate_item(identifier)
+      endpoint = ENDPOINTS[:validate_item]
+      headers  = [
+        *auth_header(@client.access_token),
+        *content_type_header('application/json'),
+      ].to_h
+
+      post_request(endpoint, "'#{identifier}'", headers)
+    end
+
+    # `identifier` can be Item #, Mfg Model #, or UPC
+    def catalog_feed_item(identifier)
+      endpoint = ENDPOINTS[:catalog_feed_item]
+      headers  = [
+        *auth_header(@client.access_token),
+        *content_type_header('application/json'),
+      ].to_h
+
+      post_request(endpoint, "'#{identifier}'", headers)
+    end
+
+  end
+end

data/lib/lipseys/order.rb

@@ -1,74 +1,55 @@
-module Lipseys
-  # Required options when submitting an order:
-  #
-  # * `:email` and `:password`
-  # * `:item_number` OR `:upc`
-  # * `:quantity`
-  # * `:purchase_order`
-  #
-  # Optional order params:
-  #
-  # * `:notify_by_email` (boolean)
-  # * `:note`
-  class Order < SoapClient
-
-    def initialize(options = {})
-      requires!(options, :username, :password, :quantity, :purchase_order)
-      @email = options[:username]
-      @password = options[:password]
-      @quantity = options[:quantity]
-
-      @notify_by_email = (options[:notify_by_email] == true ? 'Y' : nil)
-      @purchase_order = options[:purchase_order]
-      @note = options[:note]
-
-      @item_number_or_upc = options[:item_number] || options[:upc]
-      raise ArgumentError.new("Either :item_number or :upc must be given") if @item_number_or_upc.nil?
-    end
-
+require 'lipseys/api'
 
-    def self.submit!(*args)
-      new(*args).submit!
-    end
-
-    def submit!
-      response = soap_client.call(:submit_order, message: build_order_data)
-
-      raise Lipseys::NotAuthenticated if not_authenticated?(response)
-
-      order_result = response.body[:submit_order_response][:submit_order_result]
-
-      {
-        order_number: order_result[:order_no],
-        new_order: (order_result[:new_order] == 'Y'),
-        success: (order_result[:success] == 'Y'),
-        description: order_result[:return_desc],
-        quantity_received: Integer(order_result[:qty_received]),
-      }
-    rescue Savon::Error => e
-      { success: false, description: e.to_s }
+module Lipseys
+  class Order < Base
+
+    include Lipseys::API
+
+    SUBMIT_TO_STORE_ATTRS = {
+      permitted: %i( po_number disable_email items item_no quantity note ).freeze,
+      required:  %i( items item_no quantity ).freeze
+    }
+
+    SUBMIT_TO_DROP_SHIP_ATTRS = {
+      permitted: %i(
+        warehouse po_number billing_name billing_address_line_1 billing_address_line_2 billing_address_city
+        billing_address_state billing_address_zip shipping_name shipping_address_line_1 shipping_address_line_2
+        shipping_address_city shipping_address_state shipping_address_zip message_for_sales_exec disable_email
+        items item_no quantity note overnight
+      ).freeze,
+      required: %i(
+        po_number billing_name billing_address_line_1  billing_address_city billing_address_state billing_address_zip
+        shipping_name shipping_address_line_1 shipping_address_city shipping_address_state shipping_address_zip
+        items item_no quantity
+      ).freeze
+    }
+
+    ENDPOINTS = {
+      submit_to_store:     "order/apiorder".freeze,
+      submit_to_drop_ship: "order/dropship".freeze,
+    }
+
+    def initialize(client)
+      @client = client
     end
 
-    private
+    def submit_to_store(order_data)
+      requires!(order_data, *SUBMIT_TO_STORE_ATTRS[:required])
 
-    def build_order_data
-      order_data = {
-        EmailAddress: @email,
-        Password: @password,
-        LipseysItemNumberOrUPC: @item_number_or_upc,
-        Qty: @quantity
-      }
+      endpoint = ENDPOINTS[:submit_to_store]
+      headers = [
+        *auth_header(@client.access_token),
+        *content_type_header('application/json'),
+      ].to_h
 
-      order_data[:NotifyByEmail] = @notify_by_email unless @notify_by_email.nil?
-      order_data[:PONumber] = @purchase_order unless @purchase_order.nil?
-      order_data[:Note] = @note unless @note.nil?
+      order_data = standardize_body_data(order_data, SUBMIT_TO_STORE_ATTRS[:permitted])
 
-      { OrderData: order_data }
+      post_request(endpoint, order_data, headers)
     end
 
-    def not_authenticated?(response)
-      order_result = response.body[:submit_order_response][:submit_order_result]
-      order_result[:success] == 'N' && order_result[:return_desc] =~ /Credentials Not Valid/i
+    def submit_to_drop_ship(order_data)
+      # NOTE: Will build this out as time permits.
+      false
     end
 
   end

data/lib/lipseys/response.rb

@@ -0,0 +1,45 @@
+module Lipseys
+  class Response
+
+    def initialize(response)
+      @response = response
+
+      case @response
+      when Net::HTTPUnauthorized
+        Lipseys::Error::NotAuthorized.new(@response.body)
+      when Net::HTTPNotFound
+        Lipseys::Error::NotFound.new(@response.body)
+      when Net::HTTPNoContent
+        Lipseys::Error::NoContent.new(@response.body)
+      when Net::HTTPOK, Net::HTTPSuccess
+        _data = (JSON.parse(@response.body) if @response.body.present?)
+
+        @data = case
+        when _data.is_a?(Hash)
+          _data.deep_symbolize_keys
+        when _data.is_a?(Array)
+          _data.map(&:deep_symbolize_keys)
+        end
+      else
+        raise Lipseys::Error::RequestError.new(@response.body)
+      end
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def body
+      @data
+    end
+
+    def fetch(key)
+      @data.fetch(key)
+    end
+
+    def success?
+      !!self[:success] && self[:errors].empty?
+    end
+
+  end
+end

data/lib/lipseys/user.rb

@@ -1,29 +1,14 @@
 module Lipseys
-  class User < SoapClient
-
-    API_URL = 'http://184.188.80.195/API/validate.asmx?WSDL'
+  class User < Base
 
     def initialize(options = {})
       requires!(options, :username, :password)
-      @options = options
-    end
 
-    def authenticated?
-      validate[:success]
+      @client = Lipseys::Client.new(username: options[:username], password: options[:password])
     end
 
-    def validate
-      body = { Credentials: { EmailAddress: @options[:username], Password: @options[:password] } }
-      response = soap_client(API_URL).call(:validate_dealer, message: body)
-
-      result = response.body[:validate_dealer_response][:validate_dealer_result]
-
-      {
-        success: (result[:success] == 'Y'),
-        description: result[:return_desc],
-      }
-    rescue Savon::Error => e
-      { success: false, description: e.to_s }
+    def authenticated?
+      @client.access_token.present?
     end
 
   end

data/lib/lipseys/version.rb

@@ -1,3 +1,3 @@
 module Lipseys
-  VERSION = '5.0.1'.freeze
+  VERSION = '6.0.0'.freeze
 end

data/lipseys.gemspec

@@ -6,8 +6,8 @@ require 'lipseys/version'
 Gem::Specification.new do |spec|
   spec.name          = "lipseys"
   spec.version       = Lipseys::VERSION
-  spec.authors       = ["Dale Campbell"]
-  spec.email         = ["oshuma@gmail.com"]
+  spec.authors       = ["Jeffrey Dill"]
+  spec.email         = ["jeffdill2@gmail.com"]
 
   spec.summary       = %q{Ruby library for Lipsey's API.}
   spec.description   = %q{}
@@ -17,16 +17,14 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
   end
+
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "nokogiri", "~> 1.6"
-  spec.add_dependency "savon", "~> 2.11.1"
-
   spec.add_development_dependency "activesupport", "~> 5"
   spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "webmock", "~> 2.3"
 end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: lipseys
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 6.0.0
 platform: ruby
 authors:
-- Dale Campbell
+- Jeffrey Dill
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-16 00:00:00.000000000 Z
+date: 2020-03-31 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: nokogiri
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: savon
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.11.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.11.1
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +42,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -110,7 +82,7 @@ dependencies:
         version: '2.3'
 description: ''
 email:
-- oshuma@gmail.com
+- jeffdill2@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -127,14 +99,16 @@ files:
 - bin/console
 - bin/setup
 - lib/lipseys.rb
+- lib/lipseys/api.rb
 - lib/lipseys/base.rb
 - lib/lipseys/catalog.rb
+- lib/lipseys/client.rb
+- lib/lipseys/error.rb
 - lib/lipseys/image.rb
 - lib/lipseys/inventory.rb
-- lib/lipseys/invoice.rb
+- lib/lipseys/items.rb
 - lib/lipseys/order.rb
-- lib/lipseys/parser.rb
-- lib/lipseys/soap_client.rb
+- lib/lipseys/response.rb
 - lib/lipseys/user.rb
 - lib/lipseys/version.rb
 - lipseys.gemspec
@@ -158,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
 summary: Ruby library for Lipsey's API.

data/lib/lipseys/invoice.rb

@@ -1,83 +0,0 @@
-module Lipseys
-  # In addition to the `:email` and `:password` options, finding invoices requires
-  # either an `:order_number` **OR** a `:purchase_order`.
-  #
-  # The response structure will look like this:
-  #
-  #   {
-  #     invoices_found: 1,
-  #     description: "1 Invoice(s) found.",
-  #     invoices: {
-  #       invoice_detail: {
-  #         invoice_no: "...",
-  #         ship_to_location: "...",
-  #         tracking_no: "...",
-  #         line_items: {
-  #           item_detail: {
-  #             item_no: "...",
-  #             upc: "...",
-  #             qty: "...",
-  #             serialized_item: "...",
-  #             serial_numbers: {
-  #               string: "..."
-  #             }
-  #           }
-  #         }
-  #       }
-  #     }
-  #   }
-  class Invoice < SoapClient
-
-    def initialize(options = {})
-      requires!(options, :username, :password)
-      @email = options[:username]
-      @password = options[:password]
-
-      @order_number = options[:order_number]
-      @purchase_order = options[:purchase_order]
-      raise ArgumentError.new("Either :order_number or :purchase_order is required") if @order_number.nil? && @purchase_order.nil?
-    end
-
-
-    def self.all(*args)
-      new(*args).all
-    end
-
-    def all
-      response = soap_client.call(:get_invoices, message: build_inquiry_data)
-
-      raise Lipseys::NotAuthenticated if not_authenticated?(response)
-
-      invoice_result = response.body[:get_invoices_response][:get_invoices_result]
-
-      {
-        invoices_found: Integer(invoice_result[:invoices_found]),
-        description: invoice_result[:return_desc],
-
-        invoices: invoice_result[:invoices]
-      }
-    rescue Savon::Error => e
-      { success: false, description: e.to_s }
-    end
-
-    private
-
-    def build_inquiry_data
-      inquiry_data = {
-        EmailAddress: @email,
-        Password: @password
-      }
-
-      inquiry_data[:OrderNo] = @order_number unless @order_number.nil?
-      inquiry_data[:PONumber] = @purchase_order unless @purchase_order.nil?
-
-      { InquiryData: inquiry_data }
-    end
-
-    def not_authenticated?(response)
-      invoice_result = response.body[:get_invoices_response][:get_invoices_result]
-      invoice_result[:return_desc] =~ /Credentials Not Valid/i
-    end
-
-  end
-end

data/lib/lipseys/parser.rb

@@ -1,25 +0,0 @@
-module Lipseys
-  class Parser
-
-    attr_reader :file
-
-    def initialize(file)
-      @file = file
-    end
-
-    def self.parse(file, node_name, &block)
-      new(file).parse(node_name, &block)
-    end
-
-    def parse(node_name, &block)
-      File.open(@file) do |file|
-        Nokogiri::XML::Reader.from_io(file).each do |node|
-          if node.name == node_name and node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
-            yield(Nokogiri::XML(node.outer_xml))
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/lipseys/soap_client.rb

@@ -1,13 +0,0 @@
-module Lipseys
-  class SoapClient < Base
-
-    API_URL = 'http://184.188.80.195/webservice/LipseyAPI.asmx?WSDL'
-
-    protected
-
-    def soap_client(api_url = API_URL)
-      @soap_client ||= Savon.client(wsdl: api_url, convert_request_keys_to: :none)
-    end
-
-  end
-end