lightspeed_pos 0.1.0 → 0.6.0

data/Rakefile

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"

data/bin/console

@@ -1,14 +1,41 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-require "bundler/setup"
-require "lightspeed/pos"
+require 'bundler/setup'
+require 'dotenv'
+require 'lightspeed_pos'
+Lightspeed::Request.verbose = true
 
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
+class TokenHolder
+  def initialize(token: nil, refresh_token: nil)
+    @token = token
+    @refresh_token = refresh_token
+  end
+
+  def oauth_token
+    @token
+  end
+
+  def refresh_oauth_token
+    raise "Token expired, refresh not yet implemented"
+  end
+end
 
-# (If you use this, don't forget to add pry to your Gemfile!)
 # require "pry"
 # Pry.start
+Dotenv.load
+def client
+  token = ENV['LIGHTSPEED_OAUTH_TOKEN']
+  refresh_token = ENV['LIGHTSPEED_OAUTH_REFRESH_TOKEN']
+  raise 'set LIGHTSPEED_OAUTH_TOKEN as an envorinment variable to use this' unless token
+  raise 'set LIGHTSPEED_OAUTH_REFRESH_TOKEN as an envorinment variable to use this' unless refresh_token
+  token_holder = Tokenholder.new(token: token, refresh_token: refresh_token)
+  @client ||= Lightspeed::Client.new(oauth_token_holder: token_holder)
+end
+
+def account
+  client.accounts.first
+end
 
-require "irb"
+require 'irb'
 IRB.start

data/lib/lightspeed/account.rb

@@ -1,48 +1,55 @@
-require 'lightspeed/base'
-require 'lightspeed/categories'
-require 'lightspeed/items'
-require 'lightspeed/item_matrices'
+# frozen_string_literal: true
+
+require 'uri'
+require_relative 'categories'
+require_relative 'employees'
+require_relative 'items'
+require_relative 'item_matrices'
+require_relative 'item_attribute_sets'
+require_relative 'images'
+require_relative 'inventories'
+require_relative 'orders'
+require_relative 'price_levels'
+require_relative 'sales'
+require_relative 'shops'
+require_relative 'special_orders'
+require_relative 'vendors'
+require_relative 'customers'
 
 module Lightspeed
-  class Account < Lightspeed::Base
-    attr_accessor :id, :name, :link
-
-    def client
-      owner
-    end
-
-    def items
-      item_proxy
-    end
-
-    def categories
-      category_proxy
-    end
-
-    def item_matrices
-      item_matrices_proxy
-    end
-
-    def instantiate(*args)
-      client.instantiate(self, *args)
-    end
-
-    private
-
-    def self.id_field
-      "accountID"
-    end
-
-    def item_proxy
-      @item_proxy ||= Lightspeed::Items.new(self)
-    end
-
-    def category_proxy
-      @category_proxy ||= Lightspeed::Categories.new(self)
-    end
-
-    def item_matrices_proxy
-      @item_matrices_proxy ||= Lightspeed::ItemMatrices.new(self)
+  class Account < Lightspeed::Resource
+    fields(
+      accountID: :id,
+      name: :string,
+      link: :hash
+    )
+    relationships(
+      :Categories,
+      :Employees,
+      :Images,
+      :Inventories,
+      :ItemMatrices,
+      :ItemAttributeSets,
+      :Items,
+      :Orders,
+      :PriceLevels,
+      :Sales,
+      :Shops,
+      :SpecialOrders,
+      :Vendors,
+      :Customers
+    )
+
+    def account
+      self
+    end
+
+    def link
+      if @link.is_a?(Hash)
+        @link['@attributes']['href']
+      else
+        @link
+      end
     end
   end
 end

data/lib/lightspeed/accounts.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'collection'
+require_relative 'account'
+
+module Lightspeed
+  class Accounts < Lightspeed::Collection
+    def base_path
+      '/Account'
+    end
+
+    def account
+      first_loaded || first
+    end
+
+    def page(n, **args)
+      # turns out lightspeed doesn't respect pagination for accounts.
+      # so page(1) is identical to page(0).
+      # they should be different, thus.
+      # if someone has more than 100 store accounts, well, good for them.
+      n.zero? ? super : []
+    end
+  end
+end

data/lib/lightspeed/categories.rb

@@ -1,10 +1,12 @@
-require 'lightspeed/category'
-require 'lightspeed/account_resources'
+# frozen_string_literal: true
+
+require_relative 'category'
+require_relative 'collection'
 
 module Lightspeed
-  class Categories < Lightspeed::AccountResources
-    def self.resource_name
-      "Category"
+  class Categories < Lightspeed::Collection
+    def load_relations_default
+      nil
     end
   end
 end

data/lib/lightspeed/category.rb

@@ -1,10 +1,21 @@
-module Lightspeed
-  class Category < Base
-    attr_accessor :name, :nodeDepth, :fullPathName, :leftNode, :rightNode, :timeStamp, :parentID,
-      :createTime
+# frozen_string_literal: true
+
+require_relative 'resource'
 
-    def self.id_field
-      "categoryID"
-    end
+module Lightspeed
+  class Category < Lightspeed::Resource
+    fields(
+      categoryID: :id,
+      name: :string,
+      nodeDepth: :integer,
+      fullPathName: :string,
+      leftNode: :integer,
+      rightNode: :integer,
+      createTime: :datetime,
+      timeStamp: :datetime,
+      parentID: :id,
+      Category: :hash
+    )
+    relationships Parent: :Category
   end
 end

data/lib/lightspeed/client.rb

@@ -1,45 +1,59 @@
-require 'lightspeed/account'
-require 'lightspeed/request'
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/wrap'
+
+require_relative 'accounts'
+require_relative 'request'
+require_relative 'request_throttler'
 
 module Lightspeed
   class Client
-    attr_accessor :api_key, :oauth_token
+    attr_accessor :throttler
 
-    def initialize(api_key: nil, oauth_token: nil)
-      @api_key = api_key
-      @oauth_token = oauth_token
-    end
+    def initialize(oauth_token_holder: nil, oauth_token: nil)
+      @oauth_token_holder = oauth_token_holder
+      @throttler = Lightspeed::RequestThrottler.new
 
-    def request(**args)
-      Lightspeed::Request.new(self, **args)
+      raise "Passing an oauth token is no longer supported. Pass a token holder instead." if oauth_token
     end
 
     # Returns a list of accounts that you have access to.
     def accounts
-      request = request(method: :get, path: "/Account.json")
-      response = request.perform
-      instantiate(response["Account"], Lightspeed::Account)
+      @accounts ||= Lightspeed::Accounts.new(context: self)
     end
 
-    # Instantiates a bunch of records from Lightspeed into their proper classes.
-    def instantiate(owner = self, records, klass)
-      records = splat(records)
-      records.map do |record|
-        klass.new(owner, record)
-      end
+    def get(**args)
+      perform_request(**args, method: :get)
+    end
+
+    def post(**args)
+      perform_request(**args, method: :post)
+    end
+
+    def put(**args)
+      perform_request(**args, method: :put)
+    end
+
+    def delete(**args)
+      perform_request(**args, method: :delete)
+    end
+
+    def oauth_token
+      @oauth_token_holder.oauth_token
+    end
+
+    def refresh_oauth_token
+      @oauth_token_holder.refresh_oauth_token
     end
 
     private
 
-    # Converts a thing to an Array unless it is already.
-    # Unfortunately necessary because Lightspeed's API may return an object,
-    # or an array of objects.
-    #
-    # The compact is becuase it may return nothing at all.
-    # In the example of fetching categories resource where there are no categories,
-    # response["Category"] will not be present.
-    def splat(thing)
-      (thing.is_a?(Array) ? thing : [thing]).compact
+    def perform_request(**args)
+      @throttler.perform_request request(**args)
+    end
+
+    def request **args
+      Lightspeed::Request.new(self, **args)
     end
   end
 end

data/lib/lightspeed/collection.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/array/wrap'
+
+module Lightspeed
+  class Collection
+    PER_PAGE = 100 # the max page of records returned in a request
+
+    attr_accessor :context, :resources
+
+    def initialize(context:, attributes: nil)
+      self.context = context
+      instantiate(attributes)
+    end
+
+    def account
+      context.account
+    end
+
+    def unload
+      @resources = {}
+    end
+
+    def client
+      return context if context.is_a?(Lightspeed::Client)
+      account.client
+    end
+
+    def first(params: {})
+      params = params.merge(limit: 1)
+      instantiate(get(params: params)).first
+    end
+
+    def size(params: {})
+      params = params.merge(limit: 1, load_relations: nil)
+      get(params: params)['@attributes']['count'].to_i
+    end
+    alias_method :length, :size
+
+    def each_loaded
+      @resources ||= {}
+      @resources.each_value
+    end
+
+    def all_loaded
+      each_loaded.to_a
+    end
+
+    def first_loaded
+      each_loaded.first
+    end
+
+    def size_loaded
+      @resources.size
+    end
+
+    def all(params: {})
+      enum_page(params: params).to_a.flatten(1)
+    end
+
+    def each_page(per_page: PER_PAGE, params: {}, &block)
+      enum_page(per_page: per_page, params: params).each(&block)
+    end
+
+    def enum_page(per_page: PER_PAGE, params: {})
+      Enumerator.new do |yielder|
+        loop.with_index do |_, n|
+          resources = page(n, per_page: per_page, params: params)
+          yielder << resources
+          raise StopIteration if resources.length < per_page
+        end
+      end
+    end
+
+    def enum(per_page: PER_PAGE, params: {})
+      Enumerator.new do |yielder|
+        each_page(per_page: per_page, params: params) do |page|
+          page.each { |resource| yielder << resource }
+        end
+      end
+    end
+
+    def each(per_page: PER_PAGE, params: {}, &block)
+      enum(per_page: per_page, params: params).each(&block)
+    end
+
+    def find(id)
+      first(params: { resource_class.id_field => id }) || handle_not_found(id)
+    end
+
+    def create(attributes = {})
+      instantiate(post(body: Yajl::Encoder.encode(attributes))).first
+    end
+
+    def update(id, attributes = {})
+      instantiate(put(id, body: Yajl::Encoder.encode(attributes))).first
+    end
+
+    def destroy(id)
+      instantiate(delete(id)).first
+    end
+
+    def self.collection_name
+      name.demodulize
+    end
+
+    def self.resource_name
+      collection_name.singularize
+    end
+
+    def self.resource_class
+      "Lightspeed::#{resource_name}".constantize
+    end
+
+    def base_path
+      "#{account.base_path}/#{resource_name}"
+    end
+
+    def inspect
+      "#<#{self.class.name} API#{base_path}>"
+    end
+
+    def as_json
+      return if all_loaded.empty?
+      { resource_name => all_loaded.as_json }
+    end
+    alias_method :to_h, :as_json
+
+    def to_json
+      Yajl::Encoder.encode(as_json)
+    end
+
+    def page(n, per_page: PER_PAGE, params: {})
+      params = params.merge(limit: per_page, offset: per_page * n)
+      instantiate(get(params: params))
+    end
+
+    def load_relations_default
+      'all'
+    end
+
+    private
+
+    def handle_not_found(id)
+      raise Lightspeed::Error::NotFound, "Could not find a #{resource_name} with #{resource_class.id_field}=#{id}"
+    end
+
+    def context_params
+      if context.class.respond_to?(:id_field) &&
+         resource_class.method_defined?(context.class.id_field.to_sym)
+        { context.class.id_field => context.id }
+      else
+        {}
+      end
+    end
+
+    def instantiate(response)
+      return [] unless response.is_a?(Hash)
+      @resources ||= {}
+      Array.wrap(response[resource_name]).map do |resource|
+        resource = resource_class.new(context: self, attributes: resource)
+        @resources[resource.id] = resource
+      end
+    end
+
+    def resource_class
+      self.class.resource_class
+    end
+
+    def resource_name
+      self.class.resource_name
+    end
+
+    def get(params: {})
+      params = { load_relations: load_relations_default }
+        .merge(context_params)
+        .merge(params)
+        .compact
+      client.get(
+        path: collection_path,
+        params: params
+      )
+    end
+
+    def post(body:)
+      client.post(
+        path: collection_path,
+        body: body
+      )
+    end
+
+    def put(id, body:)
+      client.put(
+        path: resource_path(id),
+        body: body
+      )
+    end
+
+    def delete(id)
+      client.delete(
+        path: resource_path(id)
+      )
+    end
+
+    def collection_path
+      "#{base_path}.json"
+    end
+
+    def resource_path(id)
+      "#{base_path}/#{id}.json"
+    end
+  end
+end