lightspeed_pos 0.1.0 → 0.6.0

data/lib/lightspeed/orders.rb

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

data/lib/lightspeed/price_level.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'resource'
+
+module Lightspeed
+  class PriceLevel < Lightspeed::Resource
+    fields(
+      priceLevelID: :id,
+      name: :string,
+      archived: :boolean,
+      canBeArchived: :boolean,
+      type: :string,
+      Calculation: :String
+    )
+  end
+end

data/lib/lightspeed/price_levels.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'collection'
+
+require_relative 'price_level'
+
+module Lightspeed
+  class PriceLevels < Lightspeed::Collection
+  end
+end

data/lib/lightspeed/prices.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+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(v["amount"])] }.to_h
+    end
+
+    def as_json
+      attributes
+    end
+    alias_method :to_h, :as_json
+
+    def to_json
+      Yajl::Encoder.encode(as_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,124 @@
+# frozen_string_literal: true
+
+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.
+
+    class << self
+      attr_writer :verbose
+    end
+
+    def self.verbose?
+      !! @verbose
+    end
 
-    def self.base_url
-      "https://api.merchantos.com/API"
+    def self.base_host
+      "api.merchantos.com"
+    end
+
+    def self.base_path
+      "/API"
     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
+      @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
+      @client = client
+      set_authorization_header
+    end
 
-      @raw_request.options[:userpwd] = "#{client.api_key}:apikey" if client.api_key
+    def set_authorization_header
+      @raw_request["Authorization"] = "Bearer #{@client.oauth_token}" if @client.oauth_token
     end
 
-    def perform
-      response = raw_request.run
-      if response.code == 200
+    def perform_raw
+      response = @http.request(raw_request)
+      extract_rate_limits(response)
+      if response.code == "200"
         handle_success(response)
       else
         handle_error(response)
       end
     end
 
+    def perform
+      perform_raw
+    rescue Lightspeed::Error::Throttled
+      retry_throttled_request
+    rescue Lightspeed::Error::Unauthorized => e
+      raise e if @attempted_oauth_token_refresh
+      @client.refresh_oauth_token
+      set_authorization_header
+      @attempted_oauth_token_refresh = true
+      perform
+    end
+
     private
 
     def handle_success(response)
-      JSON.parse(response.body)
+      json = Yajl::Parser.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 '403' then Lightspeed::Error::NotAuthorized
+      when '404' then Lightspeed::Error::NotFound
+      when '429' then Lightspeed::Error::Throttled
+      when /5../ then Lightspeed::Error::InternalServerError
+      else Lightspeed::Error
       end
 
-      raise error.new(data["message"]) if error # rubocop:disable RaiseArgs
+      # We may not get back valid JSON for a failed request
+      begin
+        data = Yajl::Parser.parse(response.body)
+        raise error, data["message"]
+      rescue Yajl::ParseError
+        raise error, response.code
+      end
+    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
+
+    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

data/lib/lightspeed/request_throttler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lightspeed
+  class RequestThrottler
+    attr_accessor :bucket_level, :bucket_max, :units_per_second
+
+    def initialize
+      @units_per_second = 0.5
+      @bucket_max = Float::INFINITY
+      @bucket_level = 0
+    end
+
+    def perform_request request
+      u = units request
+      sleep(u / @units_per_second) if @bucket_level + u > @bucket_max
+      response = request.perform
+      extract_rate_limits request
+      response
+    end
+
+    private
+
+    def units request
+      if request.raw_request.is_a? Net::HTTP::Get then 1 else 10 end
+    end
+
+    def extract_rate_limits request
+      @bucket_max, @bucket_level = request.bucket_max, request.bucket_level
+      @units_per_second = @bucket_max/60.0
+    end
+
+  end
+end

data/lib/lightspeed/resource.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+require 'active_support/core_ext/string'
+require 'active_support/core_ext/hash/slice'
+
+require_relative 'collection'
+
+module Lightspeed
+  class ID < Integer; end
+  class Link; end # rubocop:disable Lint/EmptyClass
+  class Resource
+    attr_accessor :id, :attributes, :client, :context, :account
+
+    def initialize(client: nil, context: nil, attributes: {})
+      self.client = client
+      self.context = context
+      self.attributes = attributes
+    end
+
+    def attributes=(attributes)
+      @attributes = attributes
+      attributes.each do |key, value|
+        send(:"#{key}=", value) if self.respond_to?(:"#{key}=")
+      end
+      self.id = send(self.class.id_field)
+      attributes
+    end
+
+    def account
+      @account || context.try(:account)
+    end
+
+    def self.fields(fields = {})
+      @fields ||= []
+      attr_writer(*fields.keys)
+
+      fields.each do |name, klass|
+        @fields << define_method(name) do
+          get_transformed_value(name, klass)
+        end
+      end
+      @fields
+    end
+
+    def get_transformed_value(name, kind)
+      value = instance_variable_get("@#{name}")
+      if value.is_a?(String)
+        case kind
+        when :string then value
+        when :id, :integer then value.to_i
+        when :datetime then DateTime.parse(value)
+        when :boolean then value == 'true'
+        when :decimal then BigDecimal(value)
+        when :hash then Hash.new(value)
+        else
+          raise ArgumentError, "Could not transform value #{value} to a #{kind}"
+        end
+      else
+        value
+      end
+    end
+
+    def client
+      @client || context.try(:client)
+    end
+
+    def load
+      self.attributes = get[resource_name] if (attributes.keys - [self.class.id_field]).empty?
+    end
+
+    def reload
+      self.attributes = get[resource_name]
+    end
+
+    def update(attributes = {})
+      self.attributes = put(body: Yajl::Encoder.encode(attributes))[resource_name]
+    end
+
+    def destroy
+      self.attributes = delete[resource_name]
+      self
+    end
+
+    def self.resource_name
+      name.demodulize
+    end
+
+    def self.collection_name
+      resource_name.pluralize
+    end
+
+    def self.id_field
+      "#{resource_name.camelize(:lower)}ID"
+    end
+
+    def id_params
+      { self.class.id_field => id }
+    end
+
+    def self.relationships(*args)
+      @relationships ||= []
+      paired_args = args.flat_map { |r| r.is_a?(Hash) ? r.to_a : [[r, r]] }
+      paired_args.each do |(relation_name, class_name)|
+        method_name = relation_name.to_s.underscore.to_sym
+        @relationships << define_method(method_name) do
+          instance_variable_get("@#{method_name}") || get_relation(method_name, relation_name, class_name)
+        end
+      end
+      @relationships
+    end
+
+    def inspect
+      "#<#{self.class.name} API#{base_path}>"
+    end
+
+
+    def to_json
+      Yajl::Encoder.encode(as_json)
+    end
+
+    def as_json
+      fields_to_h.merge(relationships_to_h).reject { |_, v| v.nil? || v == {} }
+    end
+    alias_method :to_h, :as_json
+
+    def base_path
+      if context.is_a?(Lightspeed::Collection)
+        "#{context.base_path}/#{id}"
+      else
+        "#{account.base_path}/#{resource_name}/#{id}"
+      end
+    end
+
+    def singular_path_parent
+      context
+    end
+
+    def resource_name
+      self.class.resource_name
+    end
+
+    def read_attribute_for_serialization(method_name)
+      method_name = method_name.to_sym
+
+      if self.class.fields.include?(method_name) || self.class.relationships.include?(method_name)
+        send(method_name)
+      end
+    end
+
+    private
+
+    def fields_to_h
+      self.class.fields.map { |f| [f, send(f)] }.to_h
+    end
+
+    def relationships_to_h
+      self.class.relationships.map { |r| [r.to_s.camelize, send(r).to_h] }.to_h
+    end
+
+    def collection_class
+      "Lightspeed::#{self.class.collection_name}".constantize
+    end
+
+    def get_relation(method_name, relation_name, class_name)
+      klass = "Lightspeed::#{class_name}".constantize
+      case
+      when klass <= Lightspeed::Collection then get_collection_relation(method_name, relation_name, klass)
+      when klass <= Lightspeed::Resource then get_resource_relation(method_name, relation_name, klass)
+      end
+    end
+
+    def get_collection_relation(method_name, relation_name, klass)
+      collection = klass.new(context: self, attributes: attributes[relation_name.to_s])
+      instance_variable_set("@#{method_name}", collection)
+    end
+
+    def get_resource_relation(method_name, relation_name, klass)
+      id_field = "#{relation_name.to_s.camelize(:lower)}ID" # parentID != #categoryID, so we can't use klass.id_field
+      resource = if send(id_field).to_i.nonzero?
+        rel_attributes = attributes[klass.resource_name] || { klass.id_field => send(id_field) }
+        klass.new(context: self, attributes: rel_attributes).tap(&:load)
+      end
+      instance_variable_set("@#{method_name}", resource)
+    end
+
+    def context_params
+      if context.respond_to?(:id_field) &&
+         respond_to?(context.id_field.to_sym)
+        { context.id_field => context.id }
+      else
+        {}
+      end
+    end
+
+    def get(params: {})
+      params = { load_relations: 'all' }.merge(context_params).merge(params)
+      client.get(
+        path: resource_path,
+        params: params
+      )
+    end
+
+    def put(body:)
+      client.put(
+        path: resource_path,
+        body: body
+      )
+    end
+
+    def delete
+      client.delete(
+        path: resource_path
+      )
+    end
+
+    def resource_path
+      "#{base_path}.json"
+    end
+  end
+end