lightspeed_pos 0.1.0 → 0.2.0

data/lib/lightspeed/employee.rb

@@ -0,0 +1,25 @@
+require_relative 'resource'
+
+module Lightspeed
+  class Employee < Lightspeed::Resource
+    fields(
+      employeeID: :id,
+      firstName: :string,
+      lastName: :string,
+      accessPin: :string,
+      lockOut: :boolean,
+      archived: :boolean,
+      contactID: :integer,
+      clockInEmployeeHoursID: :integer,
+      employeeRoleID: :integer,
+      limitToShopID: :integer,
+      lastShopID: :integer,
+      lastSaleID: :integer,
+      lastRegisterID: :integer,
+      timeStamp: :datetime,
+      Contact: :hash,
+      EmployeeRole: :hash,
+      EmployeeRights: :hash
+    )
+  end
+end

data/lib/lightspeed/employees.rb

@@ -0,0 +1,8 @@
+require_relative 'collection'
+
+require_relative 'employee'
+
+module Lightspeed
+  class Employees < Lightspeed::Collection
+  end
+end

data/lib/lightspeed/{errors.rb → error.rb}

@@ -1,8 +1,9 @@
 module Lightspeed
-  module Errors
+  class Error < Exception
     class BadRequest < Exception; end # 400
     class Unauthorized < Exception; end # 401
     class NotFound < Exception; end # 404
     class InternalServerError < Exception; end # 500
+    class Throttled < Exception; end # 503
   end
 end

data/lib/lightspeed/image.rb

@@ -0,0 +1,35 @@
+require_relative 'resource'
+
+require_relative 'item'
+require_relative 'item_matrix'
+
+module Lightspeed
+  class Image < Lightspeed::Resource
+    fields(
+      imageID: :id,
+      description: :string,
+      filename: :string,
+      baseImageURL: :string,
+      publicID: :string, # part of the file path; not a Lightspeed ID
+      itemID: :id,
+      itemMatrixID: :id,
+      Item: :hash,
+      ItemMatrix: :hash
+    )
+
+    relationships :Item, :ItemMatrix
+
+    def url
+      "#{baseImageURL}#{publicID}"
+    end
+
+    def base_path
+      if context.is_a?(Lightspeed::Item) ||
+         context.is_a?(Lightspeed::ItemMatrix)
+        "#{context.base_path}/#{resource_name}/#{id}"
+      else
+        super
+      end
+    end
+  end
+end

data/lib/lightspeed/images.rb

@@ -0,0 +1,16 @@
+require_relative 'collection'
+
+require_relative 'image'
+
+module Lightspeed
+  class Images < Lightspeed::Collection
+    def base_path
+      if context.is_a?(Lightspeed::Item) ||
+         context.is_a?(Lightspeed::ItemMatrix)
+        "#{context.base_path}/#{resource_name}"
+      else
+        super
+      end
+    end
+  end
+end

data/lib/lightspeed/inventories.rb

@@ -0,0 +1,8 @@
+require_relative 'collection'
+
+require_relative 'inventory'
+
+module Lightspeed
+  class Inventories < Lightspeed::Collection
+  end
+end

data/lib/lightspeed/inventory.rb

@@ -0,0 +1,12 @@
+require_relative 'resource'
+
+require_relative 'item'
+
+module Lightspeed
+  class Inventory < Lightspeed::Resource
+    fields(
+      inventoryID: :integer
+    )
+    relationships :Item
+  end
+end

data/lib/lightspeed/item.rb

@@ -1,26 +1,62 @@
-require 'lightspeed/base'
 
-module Lightspeed
-  class Item < Lightspeed::Base
-    attr_accessor :systemSku, :defaultCost, :avgCost, :discountable, :tax,
-      :archived, :itemType, :description, :modelYear, :upc, :ean, :customSku,
-      :manufacturerSku, :createTime, :timeStamp,
+require_relative 'resource'
+
+require_relative 'item_matrix'
+require_relative 'category'
+require_relative 'images'
+require_relative 'prices'
 
-      # Association keys
-      :categoryID, :taxClassID, :departmentID, :itemMatrixID, :manufacturerID, :seasonID,
-      :defaultVendorID, :itemECommerceID,
+module Lightspeed
+  class Item < Lightspeed::Resource
+    alias_method :archive, :destroy
 
-      # Embedded
-      :ItemMatrix, :ItemAttributes, :ItemShops, :Prices, :Note
+    fields(
+      itemID: :id,
+      systemSku: :string,
+      defaultCost: :decimal,
+      avgCost: :decimal,
+      discountable: :boolean,
+      tax: :boolean,
+      archived: :boolean,
+      itemType: :string,
+      description: :string,
+      modelYear: :integer,
+      upc: :string,
+      ean: :string,
+      customSku: :string,
+      manufacturerSku: :string,
+      createTime: :datetime,
+      timeStamp: :datetime,
+      categoryID: :id,
+      taxClassID: :id,
+      departmentID: :id,
+      itemMatrixID: :id,
+      manufacturerID: :id,
+      seasonID: :id,
+      defaultVendorID: :id,
+      itemECommerceID: :id,
+      # Category: :hash,
+      TaxClass: :hash,
+      Department: :hash,
+      ItemAttributes: :hash,
+      # ItemMatrix: :hash,
+      # Images: :hash,
+      Manufacturer: :hash,
+      Note: :hash,
+      ItemECommerce: :hash,
+      ItemShops: :hash,
+      ItemComponents: :hash,
+      ItemShelfLocations: :hash,
+      ItemVendorNums: :hash,
+      CustomFieldValues: :hash,
+      Prices: :hash,
+      Tags: :hash
+    )
 
-    def self.id_field
-      "itemID"
-    end
+    relationships :ItemMatrix, :Category, :Images, DefaultVendor: :Vendor
 
-    # FUNFACT: ItemMatrix data is returned during an `update` request,
-    # but not during a `find` request.
-    def item_matrix
-      @ItemMatrix ||= owner.item_matrices.find(itemMatrixID) # rubocop:disable VariableName
+    def prices
+      @prices ||= Lightspeed::Prices.new(self.Prices)
     end
   end
 end

data/lib/lightspeed/item_attribute_set.rb

@@ -0,0 +1,13 @@
+require_relative 'resource'
+
+module Lightspeed
+  class ItemAttributeSet < Lightspeed::Resource
+    fields(
+      itemAttributeSetID: :id,
+      name: :string,
+      attributeName1: :string,
+      attributeName2: :string,
+      attributeName3: :string
+    )
+  end
+end

data/lib/lightspeed/item_attribute_sets.rb

@@ -0,0 +1,8 @@
+require_relative 'collection'
+
+require_relative 'item_attribute_set'
+
+module Lightspeed
+  class ItemAttributeSets < Lightspeed::Collection
+  end
+end

data/lib/lightspeed/item_matrices.rb

@@ -1,8 +1,9 @@
-require 'lightspeed/item_matrix'
-require 'lightspeed/account_resources'
+require_relative 'collection'
+
+require_relative 'item_matrix'
 
 module Lightspeed
-  class ItemMatrices < AccountResources
+  class ItemMatrices < Lightspeed::Collection
     def self.resource_name
       "ItemMatrix"
     end

data/lib/lightspeed/item_matrix.rb

@@ -1,17 +1,55 @@
+require_relative 'resource'
+
+require_relative 'item_attribute_set'
+require_relative 'category'
+require_relative 'items'
+
 module Lightspeed
-  class ItemMatrix < Lightspeed::Base
-    attr_accessor :description, :tax, :defaultCost, :itemType, :modelYear, :archived,
-      :timeStamp
+  class ItemMatrix < Lightspeed::Resource
+    fields(
+      itemMatrixID: :id,
+      description: :string,
+      tax: :boolean,
+      defaultCost: :decimal,
+      itemType: :string,
+      modelYear: :integer,
+      archived: :boolean,
+      timeStamp: :datetime,
+      itemAttributeSetID: :id,
+      manufacturerID: :id,
+      categoryID: :id,
+      defaultVendorID: :id,
+      taxClassID: :id,
+      seasonID: :id,
+      departmentID: :id,
+      itemECommerceID: :id,
+      itemAttributeSet: :hash,
+      Manufacturer: :hash,
+      Category: :hash,
+      TaxClass: :hash,
+      Season: :hash,
+      Department: :hash,
+      ItemECommerce: :hash,
+      Images: :hash,
+      Items: :hash,
+      CustomFieldValues: :hash,
+      Prices: :hash
+    )
+
+    relationships :ItemAttributeSet, :Category, :Items
 
-    # Association keys
-    attr_accessor :itemAttributeSetID, :manufacturerID, :categoryID, :defaultVendorID,
-      :taxClassID, :seasonID, :departmentID, :itemECommerceID
+    # overrides
 
-    # Embedded
-    attr_accessor :Prices
+    def self.collection_name
+      'ItemMatrices'
+    end
+
+    def singular_path_parent
+      account
+    end
 
-    def self.id_field
-      "itemMatrixID"
+    def prices
+      @prices ||= Lightspeed::Prices.new(self.Prices)
     end
   end
 end

data/lib/lightspeed/items.rb

@@ -1,12 +1,9 @@
-require 'lightspeed/item'
-require 'lightspeed/account_resources'
+require_relative 'collection'
+
+require_relative 'item'
 
 module Lightspeed
-  class Items < Lightspeed::AccountResources
+  class Items < Lightspeed::Collection
     alias_method :archive, :destroy
-
-    def self.resource_name
-      "Item"
-    end
   end
 end

data/lib/lightspeed/order.rb

@@ -0,0 +1,34 @@
+require_relative 'resource'
+
+module Lightspeed
+  class Order < Lightspeed::Resource
+    alias_method :archive, :destroy
+
+    fields(
+      orderID: :id,
+      orderedDate: :timestamp,
+      receivedDate: :timestamp,
+      arrivalDate: :timestamp,
+      shipInstructions: :integer,
+      stockInstructions: :integer,
+      shipCost: :decimal,
+      otherCost: :decimal,
+      complete: :boolean,
+      archived: :boolean,
+      discount: :boolean,
+      totalDiscount: :decimal,
+      totalQuantity: :decimal,
+      vendorID: :id,
+      noteID: :id,
+      shopID: :id,
+      Vendor: :hash,
+      Note: :hash,
+      Shop: :hash,
+      OrderLines: :hash,
+      CustomFieldValues: :hash,
+      timeStamp: :timestamp
+    )
+
+  end
+end
+

data/lib/lightspeed/orders.rb

@@ -0,0 +1,10 @@
+require_relative 'collection'
+
+require_relative 'order'
+
+module Lightspeed
+  class Orders < Lightspeed::Collection
+    alias_method :archive, :destroy
+  end
+end
+

data/lib/lightspeed/prices.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/string'
+require 'bigdecimal'
+
+module Lightspeed
+  class Prices
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def prices
+      @prices ||= @attributes["ItemPrice"].map { |v| [v["useType"].parameterize.underscore.to_sym, BigDecimal.new(v["amount"])] }.to_h
+    end
+
+    def as_json
+      attributes
+    end
+    alias_method :to_h, :as_json
+
+    def to_json
+      as_json.to_json
+    end
+
+    def [](key)
+      prices[key]
+    end
+
+    def inspect
+      prices.inspect
+    end
+
+    def respond_to?(method, private_method)
+      prices.keys.include?(method) || super
+    end
+
+    def method_missing(method, *args, &block)
+      if prices.keys.include?(method)
+        prices[method]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/lightspeed/request.rb

@@ -1,55 +1,101 @@
+require 'pp'
+require 'net/http'
+
 module Lightspeed
   class Request
-    attr_accessor :raw_request
+    attr_accessor :raw_request, :bucket_max, :bucket_level
+
+    SECONDS_TO_WAIT_WHEN_THROTTLED = 60 # API requirements.
 
-    def self.base_url
-      "https://api.merchantos.com/API"
+    class << self
+      attr_writer :verbose
     end
 
-    def initialize(client, method:, path:, params: nil, body: nil)
-      @raw_request = Typhoeus::Request.new(
-        self.class.base_url + path,
-        method: method,
-        body: body,
-        params: params
-      )
-
-      if client.oauth_token
-        @raw_request.options[:headers].merge!(
-          "Authorization" => "OAuth #{client.oauth_token}"
-        )
-      end
+    def self.verbose?
+      !! @verbose
+    end
 
-      @raw_request.options[:userpwd] = "#{client.api_key}:apikey" if client.api_key
+    def self.base_host
+      "api.merchantos.com"
+    end
+
+    def self.base_path
+      "/API"
+    end
+
+    def initialize(client, method:, path:, params: nil, body: nil)
+      @method = method
+      @params = params
+      @path = path
+      @bucket_max = Float::INFINITY
+      @bucket_level = 0
+      @http = Net::HTTP.new(self.class.base_host, 443)
+      @http.use_ssl = true
+      @raw_request = request_class.new(uri)
+      @raw_request.body = body if body
+      @raw_request.set_form_data(@params) if @params && @method != :get
+      @raw_request["Authorization"] = "OAuth #{client.oauth_token}" if client.oauth_token
     end
 
     def perform
-      response = raw_request.run
-      if response.code == 200
+      response = @http.request(raw_request)
+      extract_rate_limits(response)
+      if response.code == "200"
         handle_success(response)
       else
         handle_error(response)
       end
+    rescue Lightspeed::Error::Throttled
+      retry_throttled_request
     end
 
     private
 
     def handle_success(response)
-      JSON.parse(response.body)
+      json = JSON.parse(response.body)
+      pp json if self.class.verbose?
+      json
+    end
+
+    def retry_throttled_request
+      puts 'retrying throttled request after 60s.' if self.class.verbose?
+      sleep SECONDS_TO_WAIT_WHEN_THROTTLED
+      perform
     end
 
     def handle_error(response)
       data = JSON.parse(response.body)
-      error = case response.code
-      when 400
-        Lightspeed::Errors::BadRequest
-      when 401
-        Lightspeed::Errors::Unauthorized
-      when 500
-        Lightspeed::Errors::InternalServerError
+      error = case response.code.to_s
+      when '400' then Lightspeed::Error::BadRequest
+      when '401' then Lightspeed::Error::Unauthorized
+      when '404' then Lightspeed::Error::NotFound
+      when '429' then Lightspeed::Error::Throttled
+      when /5../ then Lightspeed::Error::InternalServerError
+      else Lightspeed::Error
+      end
+      raise error, data["message"]
+    end
+
+    def extract_rate_limits(response)
+      if bucket_headers = response["X-LS-API-Bucket-Level"]
+        @bucket_level, @bucket_max = bucket_headers.split("/").map(&:to_f)
       end
+    end
 
-      raise error.new(data["message"]) if error # rubocop:disable RaiseArgs
+    def uri
+      uri = self.class.base_path + @path
+      uri += "?" + URI.encode_www_form(@params) if @params && @method == :get
+      uri
     end
+
+    def request_class
+      case @method
+      when :get then Net::HTTP::Get
+      when :put then Net::HTTP::Put
+      when :post then Net::HTTP::Post
+      when :delete then Net::HTTP::Delete
+      end
+    end
+
   end
 end