noosh24 0.1.0

data/lib/noosh24/page.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Noosh24
+  class Page
+    include Enumerable
+
+    attr_reader :items, :total, :limit, :offset
+
+    def initialize(items:, total:, limit:, offset:)
+      @items = items.freeze
+      @total = total
+      @limit = limit
+      @offset = offset
+      freeze
+    end
+
+    def has_more?
+      !items.empty? && offset + items.size < total
+    end
+
+    def next_offset
+      offset + items.size
+    end
+
+    def each(&)
+      return enum_for(:each) { items.size } unless block_given?
+
+      items.each(&)
+      self
+    end
+
+    def size
+      items.size
+    end
+    alias length size
+
+    def empty?
+      items.empty?
+    end
+
+    def ==(other)
+      other.is_a?(Page) && [other.items, other.total, other.limit, other.offset] == [items, total, limit, offset]
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, items, total, limit, offset].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} items=#{items.size} total=#{total} limit=#{limit} offset=#{offset}>"
+    end
+  end
+
+  CreateReservationResult = Data.define(:reservation, :created) do
+    alias_method :created?, :created
+  end
+end

data/lib/noosh24/reservation_input.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Noosh24
+  PreOrderLine = Data.define(:item_id, :qty, :note) do
+    def self.coerce(line)
+      return line if line.is_a?(PreOrderLine)
+      raise ArgumentError, "A pre-order line is a PreOrderLine or a Hash" unless line.is_a?(Hash)
+
+      fields = line.transform_keys(&:to_s)
+      new(item_id: fields.fetch("item_id") { fields.fetch("itemId") }, qty: fields.fetch("qty"), note: fields["note"])
+    end
+
+    def initialize(item_id:, qty:, note: nil)
+      super
+    end
+
+    def to_body
+      body = { "itemId" => item_id, "qty" => qty }
+      body["note"] = note unless note.nil?
+      body
+    end
+  end
+
+  NewReservation = Data.define(
+    :date, :time, :guests, :guest_name, :phone, :email, :table_id, :zone, :special_request,
+    :allergy_note, :birthday, :child_chair, :pre_order, :external_ref
+  ) do
+    def self.coerce(reservation)
+      return reservation if reservation.is_a?(NewReservation)
+      raise ArgumentError, "A reservation is a NewReservation or a Hash" unless reservation.is_a?(Hash)
+
+      new(**reservation.transform_keys(&:to_sym))
+    end
+
+    def initialize(date:, time:, guests:, guest_name:, phone:, email: nil, table_id: nil, zone: nil,
+                   special_request: nil, allergy_note: nil, birthday: nil, child_chair: nil, pre_order: nil,
+                   external_ref: nil)
+      lines = pre_order&.map { |line| PreOrderLine.coerce(line) }&.freeze
+      super(date:, time:, guests:, guest_name:, phone:, email:, table_id:, zone:, special_request:,
+            allergy_note:, birthday:, child_chair:, pre_order: lines, external_ref:)
+    end
+
+    def idempotent?
+      !external_ref.to_s.strip.empty?
+    end
+
+    def to_body
+      body = {
+        "date" => Convert.date_param(date),
+        "time" => time,
+        "guests" => guests,
+        "guestName" => guest_name,
+        "phone" => phone
+      }
+      {
+        "email" => email, "tableId" => table_id, "zone" => zone, "specialRequest" => special_request,
+        "allergyNote" => allergy_note, "birthday" => birthday, "childChair" => child_chair
+      }.each { |key, value| body[key] = value unless value.nil? }
+      body["preOrder"] = pre_order.map(&:to_body) unless pre_order.nil?
+      body["externalRef"] = external_ref unless external_ref.nil?
+      body
+    end
+  end
+end

data/lib/noosh24/resources.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Noosh24
+  class Resource
+    def initialize(client)
+      @client = client
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+
+    private
+
+    def path_id(value)
+      raise ArgumentError, "An id is required" unless value.is_a?(String) && !value.strip.empty?
+
+      Client.escape(value)
+    end
+
+    def list_query(limit:, offset:, sort:, where:, expand: nil)
+      query = {}
+      query["limit"] = Integer(limit) unless limit.nil?
+      query["offset"] = Integer(offset) unless offset.nil?
+      sorts = strings(sort)
+      query["sort"] = sorts unless sorts.empty?
+      text = where.to_s
+      query["where"] = text unless text.empty?
+      expands = strings(expand)
+      query["expand"] = expands unless expands.empty?
+      query
+    end
+
+    def strings(value)
+      Array(value).map(&:to_s).reject(&:empty?)
+    end
+
+    def fetch_page(path, model, query)
+      _, data = @client.request("GET", path, query: query)
+      data = Convert.mapping(data)
+      items = Convert.list_of(data["items"], model)
+      Page.new(
+        items: items,
+        total: Convert.int(data["total"]) || items.size,
+        limit: Convert.int(data["limit"]) || query.fetch("limit", items.size),
+        offset: Convert.int(data["offset"]) || query.fetch("offset", 0)
+      )
+    end
+
+    def paginate(path, model, query, page_size, &block)
+      query = { "limit" => page_size, "offset" => 0 }.merge(query)
+      enum = Enumerator.new do |yielder|
+        cursor = query.dup
+        loop do
+          page = fetch_page(path, model, cursor)
+          page.items.each { |item| yielder << item }
+          break unless page.has_more?
+
+          cursor["offset"] = page.next_offset
+        end
+      end
+      return enum unless block
+
+      enum.each(&block)
+      nil
+    end
+
+    def fetch_all(path, model)
+      _, data = @client.request("GET", path)
+      Convert.list_of(Convert.mapping(data)["items"], model)
+    end
+
+    def fetch_one(path, model, query = nil)
+      _, data = @client.request("GET", path, query: query)
+      model.from_hash(data)
+    end
+  end
+
+  class Menu < Resource
+    def list_categories
+      fetch_all("/menu/categories", Category)
+    end
+
+    def list_products(limit: nil, offset: nil, sort: nil, where: nil, expand: nil)
+      fetch_page("/menu/products", Product, list_query(limit:, offset:, sort:, where:, expand:))
+    end
+
+    def iterate_products(limit: nil, offset: nil, sort: nil, where: nil, expand: nil, &)
+      page_size = strings(expand).empty? ? 100 : 50
+      paginate("/menu/products", Product, list_query(limit:, offset:, sort:, where:, expand:), page_size, &)
+    end
+
+    def get_product(product_id, expand: nil)
+      expands = strings(expand)
+      fetch_one("/menu/products/#{path_id(product_id)}", Product, expands.empty? ? nil : { "expand" => expands })
+    end
+
+    def get_stop_list
+      fetch_all("/menu/stop-list", StopListItem)
+    end
+  end
+
+  class Reservations < Resource
+    def list(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/reservations", Reservation, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/reservations", Reservation, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+
+    def get(reservation_id)
+      fetch_one("/reservations/#{path_id(reservation_id)}", Reservation)
+    end
+
+    def availability(date, time, guests: nil)
+      query = { "date" => Convert.date_param(date), "time" => time, "guests" => guests }
+      fetch_one("/reservations/availability", TableAvailability, query)
+    end
+
+    def create(reservation = nil, **fields)
+      booking = NewReservation.coerce(reservation.nil? ? fields : reservation)
+      status, data = @client.request("POST", "/reservations", body: booking.to_body, retryable: booking.idempotent?)
+      CreateReservationResult.new(reservation: Reservation.from_hash(data), created: status == 201)
+    end
+
+    def cancel(reservation_id)
+      _, data = @client.request("POST", "/reservations/#{path_id(reservation_id)}/cancel")
+      Reservation.from_hash(data)
+    end
+  end
+
+  class Orders < Resource
+    def list(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/orders", Order, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/orders", Order, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+
+    def get(order_id)
+      fetch_one("/orders/#{path_id(order_id)}", Order)
+    end
+
+    def list_bills(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/bills", Bill, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate_bills(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/bills", Bill, list_query(limit:, offset:, sort:, where:), 50, &)
+    end
+
+    def get_bill(bill_id)
+      fetch_one("/bills/#{path_id(bill_id)}", Bill)
+    end
+  end
+
+  class Payments < Resource
+    def list(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/payments", Payment, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/payments", Payment, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+
+    def get(payment_id)
+      fetch_one("/payments/#{path_id(payment_id)}", Payment)
+    end
+
+    def z_report(date = nil)
+      _, data = @client.request("GET", "/reports/z", query: date.nil? ? nil : { "date" => Convert.date_param(date) })
+      Convert.mapping(data)
+    end
+  end
+
+  class Tables < Resource
+    def list
+      fetch_all("/tables", Table)
+    end
+
+    def list_halls
+      fetch_all("/halls", Hall)
+    end
+  end
+
+  class Customers < Resource
+    def list(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/customers", Customer, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/customers", Customer, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+
+    def get(customer_id)
+      fetch_one("/customers/#{path_id(customer_id)}", Customer)
+    end
+  end
+
+  class Loyalty < Resource
+    def get_program
+      fetch_one("/loyalty/program", LoyaltyProgram)
+    end
+
+    def list_cards(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/loyalty/cards", LoyaltyCard, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate_cards(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/loyalty/cards", LoyaltyCard, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+  end
+
+  class Stock < Resource
+    def list_ingredients(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/stock/ingredients", Ingredient, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate_ingredients(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/stock/ingredients", Ingredient, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+
+    def list_moves(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/stock/moves", StockMove, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate_moves(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/stock/moves", StockMove, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+
+    def list_stores
+      fetch_all("/stock/stores", StockStore)
+    end
+  end
+
+  class Reviews < Resource
+    def list(limit: nil, offset: nil, sort: nil, where: nil)
+      fetch_page("/reviews", Review, list_query(limit:, offset:, sort:, where:))
+    end
+
+    def iterate(limit: nil, offset: nil, sort: nil, where: nil, &)
+      paginate("/reviews", Review, list_query(limit:, offset:, sort:, where:), 100, &)
+    end
+  end
+end

data/lib/noosh24/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Noosh24
+  VERSION = "0.1.0"
+end

data/lib/noosh24/where.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Noosh24
+  class Where
+    FIELD = /\A[A-Za-z][A-Za-z0-9_.]*\z/
+
+    def self.literal(value)
+      case value
+      when true then "true"
+      when false then "false"
+      when Integer then value.to_s
+      when Float then number(value)
+      when String then "'#{value.gsub("'", "''")}'"
+      when Time then "'#{timestamp(value)}'"
+      when DateTime then "'#{timestamp(value.to_time)}'"
+      when Date then "'#{value.iso8601}'"
+      when nil then raise ArgumentError, "where does not take nil"
+      else raise ArgumentError, "where takes strings, numbers, booleans, dates and times, not #{value.class}"
+      end
+    end
+
+    def self.number(value)
+      raise ArgumentError, "Numbers in where must be finite" unless value.finite?
+
+      value == value.to_i ? value.to_i.to_s : value.to_s
+    end
+
+    def self.timestamp(time)
+      return time.iso8601 if time.nsec.zero?
+
+      time.iso8601((time.nsec % 1000).zero? ? 6 : 9)
+    end
+
+    private_class_method :number, :timestamp
+
+    def initialize
+      @conditions = []
+    end
+
+    def eq(field, value) = add(field, "=", value)
+
+    def ne(field, value) = add(field, "!=", value)
+
+    def gt(field, value) = add(field, ">", value)
+
+    def gte(field, value) = add(field, ">=", value)
+
+    def lt(field, value) = add(field, "<", value)
+
+    def lte(field, value) = add(field, "<=", value)
+
+    def in(field, values)
+      items = Array(values)
+      raise ArgumentError, "in needs at least one value" if items.empty?
+
+      @conditions << "#{check(field)} in (#{items.map { |item| self.class.literal(item) }.join(', ')})"
+      self
+    end
+
+    def empty?
+      @conditions.empty?
+    end
+
+    def to_s
+      @conditions.join(" AND ")
+    end
+
+    def inspect
+      "#<#{self.class.name} #{to_s.inspect}>"
+    end
+
+    private
+
+    def add(field, operator, value)
+      @conditions << "#{check(field)} #{operator} #{self.class.literal(value)}"
+      self
+    end
+
+    def check(field)
+      raise ArgumentError, "#{field.inspect} is not a field name" unless field.is_a?(String) && FIELD.match?(field)
+
+      field
+    end
+  end
+
+  def self.where
+    Where.new
+  end
+end

data/lib/noosh24.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "date"
+require "json"
+require "net/http"
+require "openssl"
+require "time"
+require "uri"
+
+require_relative "noosh24/version"
+require_relative "noosh24/errors"
+require_relative "noosh24/convert"
+require_relative "noosh24/models"
+require_relative "noosh24/page"
+require_relative "noosh24/where"
+require_relative "noosh24/reservation_input"
+require_relative "noosh24/resources"
+require_relative "noosh24/client"

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: noosh24
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Noosh24
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Read a Noosh24 venue's menu, reservations, orders, payments, tables,
+  customers, loyalty, stock and reviews, and create or cancel reservations.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/noosh24.rb
+- lib/noosh24/client.rb
+- lib/noosh24/convert.rb
+- lib/noosh24/errors.rb
+- lib/noosh24/models.rb
+- lib/noosh24/page.rb
+- lib/noosh24/reservation_input.rb
+- lib/noosh24/resources.rb
+- lib/noosh24/version.rb
+- lib/noosh24/where.rb
+homepage: https://developer.noosh24.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://developer.noosh24.com
+  documentation_uri: https://developer.noosh24.com/reference
+  source_code_uri: https://github.com/noosh24/sdks/tree/main/ruby
+  bug_tracker_uri: https://github.com/noosh24/sdks/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Official Ruby client for the Noosh24 Open API
+test_files: []