skytab_sandbox_simulator 0.1.0

data/lib/skytab_sandbox_simulator/db/factories/simulated_orders.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+FactoryBot.define do
+  factory :simulated_order, class: "SkytabSandboxSimulator::Models::SimulatedOrder" do
+    sequence(:skytab_location_id) { |n| "LOCATION#{n}" }
+    status { "open" }
+    business_date { Date.today }
+    subtotal { 0 }
+    tax_amount { 0 }
+    tip_amount { 0 }
+    discount_amount { 0 }
+    total { 0 }
+    metadata { {} }
+
+    trait :closed do
+      status { "closed" }
+      sequence(:skytab_ticket_id) { |n| "TKT#{n}#{SecureRandom.hex(4).upcase}" }
+      subtotal { 2500 }        # cents
+      tax_amount { 206 }       # cents (8.25%)
+      tip_amount { 450 }       # cents
+      discount_amount { 0 }    # cents
+      total { 3156 }           # cents
+      meal_period { "lunch" }
+      revenue_class { "DINE_IN" }
+    end
+
+    trait :refunded do
+      status { "refunded" }
+      sequence(:skytab_ticket_id) { |n| "TKT#{n}#{SecureRandom.hex(4).upcase}" }
+      subtotal { 1800 }
+      tax_amount { 149 }
+      tip_amount { 0 }
+      discount_amount { 0 }
+      total { 1949 }
+      meal_period { "dinner" }
+      revenue_class { "DINE_IN" }
+    end
+
+    trait :voided do
+      status { "voided" }
+      subtotal { 0 }
+      tax_amount { 0 }
+      tip_amount { 0 }
+      total { 0 }
+      metadata { { "reason" => "Customer cancelled" } }
+    end
+
+    trait :with_business_type do
+      association :business_type, factory: [:business_type, :restaurant]
+    end
+
+    # Convenience: a closed order with associated payment
+    trait :with_payment do
+      closed
+
+      after(:create) do |order|
+        create(:simulated_payment, :completed, simulated_order: order, amount: order.total)
+      end
+    end
+
+    # Convenience: a closed order with a split payment
+    trait :with_split_payment do
+      closed
+      total { 4000 }
+      subtotal { 3400 }
+      tax_amount { 281 }
+      tip_amount { 319 }
+
+      after(:create) do |order|
+        half = order.total / 2
+        create(:simulated_payment, :completed, :cash_tender, simulated_order: order, amount: half)
+        create(:simulated_payment, :completed, :visa_tender, simulated_order: order, amount: order.total - half)
+      end
+    end
+
+    # Meal-period traits
+    trait :breakfast_order do
+      meal_period { "breakfast" }
+      revenue_class { "DINE_IN" }
+    end
+
+    trait :lunch_order do
+      meal_period { "lunch" }
+      revenue_class { "DINE_IN" }
+    end
+
+    trait :dinner_order do
+      meal_period { "dinner" }
+      revenue_class { "DINE_IN" }
+    end
+
+    trait :late_night_order do
+      meal_period { "late_night" }
+      revenue_class { "BAR" }
+    end
+
+    # Revenue class traits
+    trait :dine_in do
+      revenue_class { "DINE_IN" }
+    end
+
+    trait :takeout do
+      revenue_class { "TAKEOUT" }
+    end
+
+    trait :delivery do
+      revenue_class { "DELIVERY" }
+    end
+
+    trait :bar do
+      revenue_class { "BAR" }
+    end
+
+    trait :catering do
+      revenue_class { "CATERING" }
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/db/factories/simulated_payments.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+FactoryBot.define do
+  factory :simulated_payment, class: "SkytabSandboxSimulator::Models::SimulatedPayment" do
+    association :simulated_order
+    tender_name { "Cash" }
+    amount { 1500 }       # cents
+    tip_amount { 0 }      # cents
+    tax_amount { 0 }      # cents
+    status { "pending" }
+    payment_type { nil }
+
+    # ── Status traits ──────────────────────────────────────────
+
+    trait :completed do
+      status { "completed" }
+      sequence(:skytab_payment_id) { |n| "PAY#{n}#{SecureRandom.hex(4).upcase}" }
+    end
+
+    trait :failed do
+      status { "failed" }
+    end
+
+    trait :refunded do
+      status { "refunded" }
+      sequence(:skytab_payment_id) { |n| "PAY#{n}#{SecureRandom.hex(4).upcase}" }
+    end
+
+    # ── Tender traits ──────────────────────────────────────────
+
+    trait :cash_tender do
+      tender_name { "CASH" }
+      payment_type { "cash" }
+    end
+
+    trait :visa_tender do
+      tender_name { "VISA" }
+      payment_type { "card" }
+    end
+
+    trait :mastercard_tender do
+      tender_name { "MASTERCARD" }
+      payment_type { "card" }
+    end
+
+    trait :amex_tender do
+      tender_name { "AMEX" }
+      payment_type { "card" }
+    end
+
+    trait :discover_tender do
+      tender_name { "DISCOVER" }
+      payment_type { "card" }
+    end
+
+    trait :gift_card_tender do
+      tender_name { "GIFT_CARD" }
+      payment_type { "gift_card" }
+    end
+
+    trait :house_account_tender do
+      tender_name { "HOUSE_ACCOUNT" }
+      payment_type { "house_account" }
+    end
+
+    # ── Split payment trait ────────────────────────────────────
+    trait :split do
+      status { "completed" }
+      sequence(:skytab_payment_id) { |n| "PAY#{n}#{SecureRandom.hex(4).upcase}" }
+      amount { 750 }
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000000_enable_pgcrypto.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class EnablePgcrypto < ActiveRecord::Migration[8.0]
+  def change
+    enable_extension "pgcrypto"
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000001_create_business_types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateBusinessTypes < ActiveRecord::Migration[8.0]
+  def change
+    create_table :business_types, id: :uuid do |t|
+      t.string :key, null: false
+      t.string :name, null: false
+      t.text :description
+      t.string :industry
+      t.jsonb :order_profile, default: {}
+
+      t.timestamps
+    end
+
+    add_index :business_types, :key, unique: true
+    add_index :business_types, :industry
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000002_create_categories.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateCategories < ActiveRecord::Migration[8.0]
+  def change
+    create_table :categories, id: :uuid do |t|
+      t.references :business_type, null: false, foreign_key: { on_delete: :cascade }, type: :uuid
+      t.string :name, null: false
+      t.integer :sort_order, default: 0
+      t.text :description
+      t.string :tax_group
+
+      t.timestamps
+    end
+
+    add_index :categories, [:business_type_id, :name], unique: true
+    add_index :categories, :sort_order
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000003_create_items.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class CreateItems < ActiveRecord::Migration[8.0]
+  def change
+    create_table :items, id: :uuid do |t|
+      t.references :category, null: false, foreign_key: { on_delete: :cascade }, type: :uuid
+      t.string :name, null: false
+      t.integer :price, null: false  # cents
+      t.string :sku
+      t.string :unit
+      t.boolean :active, default: true, null: false
+      t.jsonb :variants, default: []
+      t.jsonb :metadata, default: {}
+
+      t.timestamps
+    end
+
+    add_index :items, [:category_id, :name], unique: true
+    add_index :items, :sku
+    add_index :items, :active
+    add_check_constraint :items, "price >= 0", name: "items_price_non_negative"
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000004_create_simulated_orders.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class CreateSimulatedOrders < ActiveRecord::Migration[8.0]
+  def change
+    create_table :simulated_orders, id: :uuid do |t|
+      t.string :skytab_ticket_id
+      t.string :skytab_location_id, null: false
+      t.references :business_type, foreign_key: true, type: :uuid
+      t.string :status, null: false, default: "open"
+      t.integer :subtotal, default: 0        # cents
+      t.integer :tax_amount, default: 0      # cents
+      t.integer :tip_amount, default: 0      # cents
+      t.integer :discount_amount, default: 0 # cents
+      t.integer :total, default: 0           # cents
+      t.string :revenue_class
+      t.string :meal_period
+      t.jsonb :metadata, default: {}
+      t.date :business_date, null: false
+
+      t.timestamps
+    end
+
+    # Unique per location — prevents duplicate inserts on retry
+    add_index :simulated_orders, [:skytab_location_id, :skytab_ticket_id],
+              unique: true,
+              where: "skytab_ticket_id IS NOT NULL",
+              name: "idx_simulated_orders_location_ticket_unique"
+    add_index :simulated_orders, :skytab_location_id
+    add_index :simulated_orders, :status
+    add_index :simulated_orders, :business_date
+    add_index :simulated_orders, :meal_period
+    add_index :simulated_orders, :revenue_class
+    add_index :simulated_orders, :created_at
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000005_create_simulated_payments.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class CreateSimulatedPayments < ActiveRecord::Migration[8.0]
+  def change
+    create_table :simulated_payments, id: :uuid do |t|
+      t.references :simulated_order, null: false, foreign_key: { on_delete: :cascade }, type: :uuid
+      t.string :skytab_payment_id
+      t.string :tender_name, null: false
+      t.integer :amount, default: 0      # cents
+      t.integer :tip_amount, default: 0  # cents
+      t.integer :tax_amount, default: 0  # cents
+      t.string :status, null: false, default: "pending"
+      t.string :payment_type
+
+      t.timestamps
+    end
+
+    # Unique — prevents duplicate payment inserts on retry
+    add_index :simulated_payments, :skytab_payment_id,
+              unique: true,
+              where: "skytab_payment_id IS NOT NULL"
+    add_index :simulated_payments, :tender_name
+    add_index :simulated_payments, :status
+    add_index :simulated_payments, :created_at
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000006_create_api_requests.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class CreateApiRequests < ActiveRecord::Migration[8.0]
+  def change
+    create_table :api_requests, id: :uuid do |t|
+      t.string :http_method, null: false
+      t.text :url, null: false
+      t.jsonb :request_payload, default: {}
+      t.jsonb :response_payload, default: {}
+      t.integer :response_status
+      t.integer :duration_ms
+      t.text :error_message
+      t.string :resource_type
+      t.string :resource_id
+      t.string :skytab_location_id
+
+      t.timestamps
+    end
+
+    add_index :api_requests, :http_method
+    add_index :api_requests, :resource_id
+    add_index :api_requests, [:resource_type, :resource_id]
+    add_index :api_requests, :created_at
+    add_index :api_requests, :response_status
+    add_index :api_requests, :skytab_location_id
+  end
+end

data/lib/skytab_sandbox_simulator/db/migrate/20260316000007_create_daily_summaries.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class CreateDailySummaries < ActiveRecord::Migration[8.0]
+  def change
+    create_table :daily_summaries, id: :uuid do |t|
+      t.string :location_id, null: false
+      t.date :business_date, null: false
+      t.integer :order_count, default: 0
+      t.integer :payment_count, default: 0
+      t.integer :refund_count, default: 0
+      t.integer :total_revenue, default: 0   # cents
+      t.integer :total_tax, default: 0       # cents
+      t.integer :total_tips, default: 0      # cents
+      t.integer :total_discounts, default: 0 # cents
+      t.jsonb :breakdown, default: {}
+
+      t.timestamps
+    end
+
+    add_index :daily_summaries, [:location_id, :business_date], unique: true
+    add_index :daily_summaries, :business_date
+    add_index :daily_summaries, :created_at
+  end
+end

data/lib/skytab_sandbox_simulator/generators/data_loader.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Generators
+    # Loads data from PostgreSQL when connected, falling back to JSON files.
+    #
+    # The DB path is preferred because it respects any runtime mutations
+    # (items deactivated, prices changed, categories added via Seeder).
+    # When no DB connection is available the loader reads the static JSON
+    # data files shipped with the gem.
+    class DataLoader
+      attr_reader :business_type
+
+      def initialize(business_type: :restaurant)
+        @business_type = business_type
+      end
+
+      # ── Primary data accessors (DB-first, JSON fallback) ───────
+
+      def categories
+        @categories ||= if db_connected?
+                           categories_from_db
+                         else
+                           load_json("categories")["categories"]
+                         end
+      end
+
+      def items
+        @items ||= if db_connected?
+                     items_from_db
+                   else
+                     load_json("items")["items"]
+                   end
+      end
+
+      # ── JSON-only accessors (no DB models for these) ───────────
+
+      def tenders
+        @tenders ||= load_json("tenders")["tenders"]
+      end
+
+      def revenue_classes
+        @revenue_classes ||= load_json("tenders")["revenue_classes"]
+      rescue Error
+        %w[DINE_IN TAKEOUT DELIVERY BAR CATERING]
+      end
+
+      def tax_rates
+        @tax_rates ||= load_json("tenders")["tax_rates"]
+      rescue Error
+        []
+      end
+
+      # ── Convenience filters ────────────────────────────────────
+
+      def items_for_category(category_name)
+        items.select { |item| item["category"] == category_name }
+      end
+
+      # ── Data source introspection ──────────────────────────────
+
+      def data_source
+        db_connected? ? :db : :json
+      end
+
+      private
+
+      def db_connected?
+        Database.connected?
+      end
+
+      # ── DB query methods ───────────────────────────────────────
+
+      def categories_from_db
+        bt = Models::BusinessType.find_by(key: business_type.to_s)
+        return load_json("categories")["categories"] unless bt
+
+        bt.categories.sorted.map do |cat|
+          {
+            "name"        => cat.name,
+            "sort_order"  => cat.sort_order,
+            "description" => cat.description
+          }
+        end
+      end
+
+      def items_from_db
+        bt = Models::BusinessType.find_by(key: business_type.to_s)
+        return load_json("items")["items"] unless bt
+
+        Models::Item.active
+                    .for_business_type(business_type.to_s)
+                    .includes(:category)
+                    .order("categories.sort_order", "items.name")
+                    .map do |item|
+          hash = {
+            "name"     => item.name,
+            "price"    => item.price,
+            "category" => item.category.name
+          }
+
+          hash["sku"]  = item.sku  if item.sku.present?
+          hash["unit"] = item.unit if item.unit.present?
+          hash
+        end
+      end
+
+      # ── JSON loading ───────────────────────────────────────────
+
+      def load_json(filename)
+        path = File.join(data_path, "#{filename}.json")
+
+        unless File.exist?(path)
+          raise Error, "Data file not found: #{path}"
+        end
+
+        JSON.parse(File.read(path))
+      end
+
+      def data_path
+        File.join(SkytabSandboxSimulator.root, "lib", "skytab_sandbox_simulator", "data", business_type.to_s)
+      end
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/generators/entity_generator.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Generators
+    # Creates restaurant entities in SkyTab (categories, items, tenders, etc.)
+    class EntityGenerator
+      LOG_SEPARATOR = ("=" * 60).freeze
+
+      attr_reader :services, :data, :logger
+
+      def initialize(services: nil, business_type: :restaurant)
+        @services = services || Services::Skytab::ServiceManager.new
+        @data = DataLoader.new(business_type: business_type)
+        @logger = SkytabSandboxSimulator.logger
+      end
+
+      # Set up all entities (categories, items)
+      def setup_all
+        logger.info LOG_SEPARATOR
+        logger.info "Setting up entities in SkyTab..."
+        logger.info LOG_SEPARATOR
+
+        results = {
+          categories: setup_categories,
+          items: setup_items
+        }
+
+        logger.info LOG_SEPARATOR
+        logger.info "Entity setup complete!"
+        logger.info "  Categories: #{results[:categories].size}"
+        logger.info "  Items: #{results[:items].size}"
+        logger.info LOG_SEPARATOR
+
+        results
+      end
+
+      # Create categories from data file
+      def setup_categories
+        logger.info "Setting up categories..."
+
+        existing = services.catalog.get_categories
+        existing_names = existing.map { |c| c["name"] }
+
+        created = []
+        data.categories.each do |cat|
+          if existing_names.include?(cat["name"])
+            logger.debug "Category already exists: #{cat['name']}"
+            next
+          end
+
+          result = services.catalog.create_category(
+            name: cat["name"],
+            sort_order: cat["sort_order"]
+          )
+          created << result if result
+        rescue StandardError => e
+          logger.warn "Failed to create category #{cat['name']}: #{e.message}"
+        end
+
+        logger.info "Created #{created.size} categories (#{existing.size} already existed)"
+        existing + created
+      end
+
+      # Create items from data file
+      def setup_items
+        logger.info "Setting up items..."
+
+        existing_items = services.catalog.get_items
+        existing_names = existing_items.map { |i| i["name"] }
+
+        # Build category name -> ID mapping
+        categories = services.catalog.get_categories
+        cat_map = categories.each_with_object({}) { |c, h| h[c["name"]] = c["id"] }
+
+        created = []
+        data.items.each do |item|
+          if existing_names.include?(item["name"])
+            logger.debug "Item already exists: #{item['name']}"
+            next
+          end
+
+          category_id = cat_map[item["category"]]
+
+          result = services.catalog.create_item(
+            name: item["name"],
+            price: item["price"],
+            category_id: category_id,
+            sku: item["sku"]
+          )
+          created << result if result
+        rescue StandardError => e
+          logger.warn "Failed to create item #{item['name']}: #{e.message}"
+        end
+
+        logger.info "Created #{created.size} items (#{existing_items.size} already existed)"
+        existing_items + created
+      end
+
+      # Delete all entities
+      def delete_all
+        logger.warn "Deleting all entities..."
+        services.catalog.delete_all
+        logger.info "All entities deleted"
+      end
+    end
+  end
+end