rbvore 0.1.1

data/lib/rbvore.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "rbvore/version"
+
+module Rbvore
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+require 'rbvore/api'
+require 'rbvore/link'
+require 'rbvore/resource'
+require 'rbvore/discount'
+require 'rbvore/menu_category'
+require 'rbvore/menu_item'
+require 'rbvore/item_modifier'
+require 'rbvore/item'
+require 'rbvore/tender_type'
+require 'rbvore/payment'
+require 'rbvore/table'
+require 'rbvore/employee'
+require 'rbvore/ticket_service_charge'
+require 'rbvore/ticket_discount'
+require 'rbvore/order_type'
+require 'rbvore/revenue_center'
+require 'rbvore/ticket'
+require 'rbvore/location'
+
+module Rbvore
+  def self.resource_subclass?(klass)
+    klass.respond_to?(:superclass) && klass.superclass == Resource
+  end
+
+  def self.resource_classes
+    @resource_classes ||= Rbvore.constants.map { |const|
+      klass = Rbvore.const_get(const)
+      klass if resource_subclass?(klass)
+    }.compact
+  end
+
+  # constantize attempts to turn a class name string into a proper constant that
+  # is a subclass of Rbvore::Resource
+  def self.constantize(name)
+    return name if resource_subclass?(name)
+
+    resource_classes.each do |klass|
+      return klass if [klass.singularize, klass.list_name, klass.pluralize].include?(name.to_s)
+    end
+
+    raise Rbvore::Error, "No Rbvore resource classes found for #{name.inspect}"
+  end
+end

data/lib/rbvore/api.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+require 'forwardable'
+require 'cgi'
+
+module Rbvore
+  class API
+    DEFAULT_HOST = ENV.fetch("OMNIVORE_HOST", "api.omnivore.io")
+    DEFAULT_API_KEY = ENV.fetch("OMNIVORE_API_KEY", nil)
+    BASE_ENDPOINT = "/1.0"
+
+    class Error < Error
+      extend Forwardable
+      attr_reader :response
+      def_delegators :response, :code, :body, :json_body, :uri
+
+      def initialize(message = nil, response:)
+        @response = response
+        @message = message || [response.code, response.message].join(" ")
+        super(@message)
+      end
+    end
+
+    class Response
+      extend Forwardable
+
+      attr_reader :original
+      def_delegators :original, :code, :body, :uri, :msg, :message, :inspect, :content_type
+
+      def initialize(obj)
+        @original = obj
+      end
+
+      def json_body
+        @json_body ||= JSON.parse(body)
+      end
+
+      def success?
+        original.is_a?(Net::HTTPSuccess)
+      end
+
+      def error
+        API::Error.new(response: self) unless success?
+      end
+    end
+
+    def initialize(host = DEFAULT_HOST)
+      @host = host
+    end
+
+    def request(method, endpoint, body: nil, params: {}, headers: {}, api_key: nil) # rubocop:disable Metrics/ParameterLists
+      api_key ||= DEFAULT_API_KEY
+      uri = build_uri(endpoint, params)
+      http_start(uri) { |http|
+        http.request(
+          build_request(method, uri, body: body, headers: headers, api_key: api_key),
+        )
+      }
+    end
+
+    def fetch_all(endpoint, resource_class, params: {}, api_key: nil)
+      response = request(
+        :get,
+        endpoint,
+        params: params,
+        api_key: api_key,
+      )
+      raise response.error unless response.success?
+
+      Resource.parse_collection(response.json_body, resource_class)
+    end
+
+    def fetch_one(endpoint, resource_class, params: {}, api_key: nil)
+      response = request(
+        :get,
+        endpoint,
+        params: params,
+        api_key: api_key,
+      )
+      raise response.error unless response.success?
+
+      Resource.parse_object(response.json_body, resource_class)
+    end
+
+    def self.endpoint(*items)
+      ([BASE_ENDPOINT] + items.map { |item|
+        case
+        when Rbvore.resource_subclass?(item)
+          item.pluralize
+        when item.nil?
+          nil
+        else
+          item.to_s
+        end
+      }.compact).join("/")
+    end
+
+  private
+
+    def build_uri(endpoint, params = nil)
+      url = if endpoint.start_with? "http"
+              endpoint
+            else
+              "https://#{@host}#{endpoint}"
+            end
+
+      URI.parse(url).tap { |uri|
+        next if params.nil? || params.empty?
+
+        uri.query = encode_form_data(params)
+      }
+    end
+
+    def encode_form_data(body)
+      body.map { |key, value| "#{key}=#{CGI.escape(value)}" }.join("&")
+    end
+
+    def build_request(method, uri, body: nil, headers: {}, api_key: nil)
+      method_class(method).new(uri.request_uri).tap { |r|
+        headers.each do |key, value|
+          r.add_field(key, value)
+        end
+        r.add_field "Accept", "application/json"
+        r.add_field "Api-Key", api_key unless api_key.nil?
+        set_body(r, body)
+      }
+    end
+
+    def http_start(uri, &block)
+      Response.new(Net::HTTP.start(uri.host, uri.port, http_opts, &block))
+    end
+
+    def http_opts
+      { use_ssl: true }
+    end
+
+    def set_body(request, body)
+      if body.is_a? String
+        request.body = body
+      elsif !body.nil?
+        request.add_field "Content-Type", "application/json"
+        request.body = body.to_json
+      end
+    end
+
+    def method_class(name)
+      case name.to_sym
+      when :get
+        Net::HTTP::Get
+      when :post
+        Net::HTTP::Post
+      end
+    end
+  end
+end

data/lib/rbvore/discount.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class Discount < Resource
+    attr_accessor :id, :available, :max_amount, :max_percent, :min_amount, :min_percent,
+                  :min_ticket_total, :name, :open, :pos_id, :type, :value, :applies_to
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+end

data/lib/rbvore/employee.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class Employee < Resource
+    attr_accessor :id, :check_name, :first_name, :last_name, :login, :middle_name,
+                  :pos_id, :start_date
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+end

data/lib/rbvore/item.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class Item < Resource
+    attr_accessor :id, :name, :price, :quantity, :seat, :sent, :split, :comment
+    attr_timestamp_accessor :sent_at
+    attr_objects menu_item: MenuItem
+    attr_collections modifiers: ItemModifier, discounts: Discount
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+
+  class VoidedItem < Item; end
+end

data/lib/rbvore/item_modifier.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class ItemModifier < Resource
+    attr_accessor :id, :name, :price, :quantity, :comment
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+end

data/lib/rbvore/link.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class UnknownLinkError < Error; end
+
+  class Link
+    attr_accessor :href, :type
+
+    def initialize(hash)
+      self.href = hash["href"]
+      self.type = hash["type"]
+    end
+
+    def type_name
+      @type_name ||= type.match(/name=(?<name>[a-z\_]+)/).named_captures["name"]
+    end
+
+    def resource_class
+      Rbvore.constantize(type_name)
+    end
+
+    def list?
+      type_name.end_with? "list"
+    end
+
+    def api
+      @api ||= API.new
+    end
+
+    def fetch(api_key: nil, params: {})
+      response = api.request(
+        :get,
+        href,
+        params: params,
+        api_key: api_key,
+      )
+      raise response.error unless response.success?
+
+      parse_resources(response.json_body)
+    end
+
+    def parse_resources(json_body)
+      if list?
+        Resource.parse_collection(json_body, resource_class)
+      else
+        Resource.parse_object(json_body, resource_class)
+      end
+    end
+  end
+end

data/lib/rbvore/location.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class Location < Resource
+    attr_accessor :address, :concept_name, :display_name, :name, :id, :custom_id,
+                  :google_place_id, :health, :latitude, :longitude, :owner, :phone,
+                  :pos_type, :status, :timezone, :website, :development
+    attr_timestamp_accessor :created, :modified
+    attr_collections(
+      tender_types: TenderType,
+      employees: Employee,
+      tables: Table,
+      order_types: OrderType,
+      revenue_centers: RevenueCenter,
+      tickets: Ticket,
+    )
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+end

data/lib/rbvore/menu_category.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class MenuCategory < Resource
+    attr_accessor :id, :level, :name, :pos_id
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+end

data/lib/rbvore/menu_item.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class MenuItem < Resource
+    attr_accessor :id, :barcodes, :in_stock, :name, :open, :pos_id, :price_per_unit
+
+    attr_collections menu_categories: MenuCategory
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+end

data/lib/rbvore/order_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class OrderType < Resource
+    attr_accessor :id, :name, :pos_id, :available
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+  end
+end

data/lib/rbvore/payment.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rbvore
+  class Payment < Resource
+    attr_accessor :id, :amount, :change, :comment, :full_name, :status, :last4, :tip, :type
+    attr_objects tender_type: TenderType
+
+    def initialize(hash)
+      set_attributes(hash)
+    end
+
+    def api
+      @api ||= API.new
+    end
+
+    def create_3rd_party(location_id:, ticket_id:, auto_close: false, api_key: nil)
+      response = api.request(
+        :post,
+        self.class.endpoint(location_id: location_id, ticket_id: ticket_id),
+        body: third_party_body(auto_close),
+        api_key: api_key,
+      )
+      raise response.error unless response.success?
+
+      Payment.new(response.json_body)
+    end
+
+    def third_party_body(auto_close)
+      {
+        amount: amount,
+        tip: tip,
+        tender_type: tender_type,
+        auto_close: auto_close,
+        comment: comment,
+        type: "3rd_party",
+      }
+    end
+  end
+end

data/lib/rbvore/resource.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require 'rbvore/resource/parsers'
+require 'rbvore/resource/names'
+require 'rbvore/resource/fetchers'
+
+module Rbvore
+  class Resource
+    extend Names
+    extend Fetchers
+    extend Parsers
+    include Parsers
+
+    attr_reader :links
+
+    # define_link_getter sets up an attribute getter that fetches from
+    # the associated link, if available
+    def self.define_link_getter(name)
+      define_method(name) do |opts = {}|
+        stored_value = instance_variable_get("@#{name}")
+        return stored_value unless stored_value.nil?
+
+        instance_variable_set("@#{name}", fetch_link(name, api_key: opts[:api_key]))
+      end
+    end
+
+    # attr_objects sets up an associated object that can be parsed from json
+    def self.attr_objects(hash)
+      hash.each do |name, klass|
+        define_link_getter(name)
+        define_method("#{name}=") do |obj|
+          instance_variable_set(
+            "@#{name}",
+            parse_object(obj, klass),
+          )
+        end
+      end
+    end
+
+    # attr_collections sets up an associated list of objects that can be
+    # parsed from the json
+    def self.attr_collections(hash)
+      hash.each do |name, klass|
+        define_link_getter(name)
+        define_method("#{name}=") do |ary|
+          instance_variable_set(
+            "@#{name}",
+            parse_collection(ary, klass),
+          )
+        end
+      end
+    end
+
+    def self.attr_timestamp_accessor(*attrs)
+      attrs.each do |name|
+        attr_reader(name)
+        define_method("#{name}=") { |value|
+          instance_variable_set("@#{name}", parse_timestamp(value))
+        }
+      end
+    end
+
+    def set_attribute(key, value)
+      setter = "#{self.class.underscore(key)}="
+      send(setter, value) if respond_to?(setter)
+    end
+
+    def set_attributes(hash) # rubocop:disable Naming/AccessorMethodName
+      hash.each do |key, value|
+        set_attribute(key, value)
+      end
+    end
+
+    def fetch_link(name, api_key: nil, params: {})
+      link = links[name.to_sym]
+      raise UnknownLinkError, "Unknown link `#{name}` for #{self.class.singularize}" if link.nil?
+
+      link.fetch(api_key: api_key, params: params)
+    end
+
+    def _links=(hash)
+      @links = hash.each_with_object({}) { |(name, data), memo|
+        memo[name.to_sym] = Link.new(data)
+      }
+    end
+
+    def _embedded=(hash)
+      set_attributes(hash)
+    end
+
+    def inspect
+      "#<#{self.class} #{[@id, @name || @display_name].join(" ")}>"
+    end
+  end
+end