skytab_sandbox_simulator 0.1.0

data/lib/skytab_sandbox_simulator/generators/order_generator.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Generators
+    # Generates realistic SkyTab orders (tickets) and payments
+    class OrderGenerator
+      # Meal periods with realistic distributions
+      MEAL_PERIODS = {
+        breakfast: { hours: 7..10, weight: 15, avg_items: 2..4, avg_party: 1..3 },
+        lunch: { hours: 11..14, weight: 30, avg_items: 3..6, avg_party: 1..4 },
+        happy_hour: { hours: 15..17, weight: 10, avg_items: 2..5, avg_party: 2..5 },
+        dinner: { hours: 17..21, weight: 35, avg_items: 3..8, avg_party: 2..6 },
+        late_night: { hours: 21..23, weight: 10, avg_items: 2..5, avg_party: 1..3 }
+      }.freeze
+
+      # Revenue class distributions by meal period
+      REVENUE_CLASS_BY_PERIOD = {
+        breakfast: { "DINE_IN" => 40, "TAKEOUT" => 50, "DELIVERY" => 10 },
+        lunch: { "DINE_IN" => 35, "TAKEOUT" => 45, "DELIVERY" => 20 },
+        happy_hour: { "DINE_IN" => 60, "BAR" => 30, "TAKEOUT" => 10 },
+        dinner: { "DINE_IN" => 65, "BAR" => 10, "TAKEOUT" => 10, "DELIVERY" => 15 },
+        late_night: { "BAR" => 40, "DINE_IN" => 30, "TAKEOUT" => 20, "DELIVERY" => 10 }
+      }.freeze
+
+      # Tip percentages by revenue class
+      TIP_RATES = {
+        "DINE_IN" => { min: 15, max: 25 },
+        "TAKEOUT" => { min: 0, max: 15 },
+        "DELIVERY" => { min: 10, max: 20 },
+        "BAR" => { min: 15, max: 25 },
+        "CATERING" => { min: 18, max: 22 }
+      }.freeze
+
+      # Order patterns by day of week
+      ORDER_PATTERNS = {
+        weekday: { min: 40, max: 60 },
+        friday: { min: 70, max: 100 },
+        saturday: { min: 80, max: 120 },
+        sunday: { min: 50, max: 80 }
+      }.freeze
+
+      # Tender distribution weights
+      TENDER_WEIGHTS = {
+        "CASH" => 15,
+        "VISA" => 30,
+        "MASTERCARD" => 20,
+        "AMEX" => 10,
+        "DISCOVER" => 5,
+        "GIFT_CARD" => 10,
+        "HOUSE_ACCOUNT" => 10
+      }.freeze
+
+      # Tax rates (divide by 10,000 for percentage)
+      SALES_TAX_RATE = 82_500  # 8.25%
+      ALCOHOL_TAX_RATE = 100_000 # 10.0%
+
+      attr_reader :services, :logger, :stats, :refund_percentage
+
+      def initialize(services: nil, refund_percentage: 5)
+        @services = services || Services::Skytab::ServiceManager.new
+        @logger = SkytabSandboxSimulator.logger
+        @refund_percentage = refund_percentage
+        @stats = {
+          orders: 0,
+          revenue: 0,
+          tips: 0,
+          tax: 0,
+          by_period: Hash.new(0),
+          by_revenue_class: Hash.new(0),
+          by_tender: Hash.new(0)
+        }
+      end
+
+      # Generate orders for today
+      #
+      # @param count [Integer, nil] Number of orders (nil for automatic based on day)
+      # @return [Array<Hash>] Generated orders
+      def generate_today(count: nil)
+        count ||= determine_order_count
+        logger.info "Generating #{count} orders for today..."
+
+        data = fetch_required_data
+        return [] unless data
+
+        orders = []
+        count.times do |i|
+          period = select_meal_period
+          order = create_realistic_order(
+            period: period,
+            data: data,
+            order_num: i + 1,
+            total_in_period: count
+          )
+
+          if order
+            orders << order
+            update_stats(order, period)
+          end
+        end
+
+        print_summary
+        orders
+      end
+
+      # Generate a realistic full day of operations
+      #
+      # @param multiplier [Float] Order multiplier (0.5 = slow, 2.0 = busy)
+      # @return [Array<Hash>] Generated orders
+      def generate_realistic_day(multiplier: 1.0)
+        logger.info "Generating realistic day (multiplier: #{multiplier})..."
+
+        data = fetch_required_data
+        return [] unless data
+
+        orders = []
+        MEAL_PERIODS.each do |period, config|
+          period_count = (config[:weight] * multiplier * 0.6).round
+          period_count = [period_count, 1].max
+
+          logger.info "#{period}: #{period_count} orders"
+
+          period_count.times do |i|
+            order = create_realistic_order(
+              period: period,
+              data: data,
+              order_num: i + 1,
+              total_in_period: period_count
+            )
+
+            if order
+              orders << order
+              update_stats(order, period)
+            end
+          end
+        end
+
+        print_summary
+        orders
+      end
+
+      private
+
+      def fetch_required_data
+        data_loader = DataLoader.new(business_type: SkytabSandboxSimulator.configuration.business_type)
+
+        items = data_loader.items
+        categories = data_loader.categories
+        tenders = data_loader.tenders
+
+        if items.empty?
+          logger.error "No items found. Run setup first."
+          return nil
+        end
+
+        { items: items, categories: categories, tenders: tenders }
+      end
+
+      def create_realistic_order(period:, data:, order_num:, total_in_period:)
+        revenue_class = select_revenue_class(period)
+        items_count = rand(MEAL_PERIODS[period][:avg_items])
+        selected_items = data[:items].sample([items_count, 1].max)
+
+        # Build SkyTab order format
+        pos_ref = "CHK-#{Time.now.strftime('%H%M')}-#{order_num.to_s.rjust(3, '0')}"
+        employee_ref = "EMP#{format('%03d', rand(1..8))}"
+
+        # Calculate totals
+        subtotal = selected_items.sum { |item| item["price"] }
+        tax = (subtotal * SALES_TAX_RATE / 1_000_000.0).round
+        total = subtotal + tax
+        tip = calculate_tip(total, revenue_class)
+
+        # Select tender
+        tender = select_tender
+
+        # Create ticket via API
+        ticket = services.order.create_ticket(
+          pos_ref: pos_ref,
+          employee_pos_ref: employee_ref,
+          revenue_class: revenue_class
+        )
+
+        return nil unless ticket
+
+        ticket_id = ticket["id"] || ticket["posRef"] || pos_ref
+
+        # Add items to ticket
+        selected_items.each do |item|
+          services.order.add_item_to_ticket(
+            ticket_id,
+            pos_ref: item["sku"] || item["name"].upcase.tr(" ", "_"),
+            name: item["name"],
+            quantity: 1,
+            price: item["price"]
+          )
+        rescue StandardError => e
+          logger.warn "Failed to add item to ticket: #{e.message}"
+        end
+
+        # Add payment
+        services.payment.add_payment(
+          ticket_id,
+          tender_pos_ref: tender,
+          amount: total,
+          tip: tip
+        )
+      rescue StandardError => e
+        logger.warn "Failed to add payment: #{e.message}"
+      end
+
+        # Close ticket
+        services.order.close_ticket(
+          ticket_id,
+          subtotal: subtotal,
+          tax: tax,
+          total: total,
+          tip: tip
+        )
+
+        # Persist to local DB if connected
+        persist_order(
+          ticket_id: ticket_id,
+          pos_ref: pos_ref,
+          revenue_class: revenue_class,
+          period: period,
+          subtotal: subtotal,
+          tax: tax,
+          total: total,
+          tip: tip,
+          tender: tender,
+          items: selected_items
+        )
+
+        {
+          "posRef" => pos_ref,
+          "status" => "closed",
+          "revenueClassPosRef" => revenue_class,
+          "employeePosRef" => employee_ref,
+          "items" => selected_items.map do |item|
+            { "posRef" => item["sku"] || item["name"], "name" => item["name"],
+              "quantity" => 1, "price" => item["price"], "total" => item["price"] }
+          end,
+          "payments" => [
+            { "tenderPosRef" => tender, "amount" => total, "tip" => tip, "status" => "completed" }
+          ],
+          "subtotal" => subtotal,
+          "tax" => tax,
+          "total" => total,
+          "tip" => tip
+        }
+      rescue StandardError => e
+        logger.error "Failed to create order: #{e.message}"
+        nil
+      end
+
+      def persist_order(ticket_id:, pos_ref:, revenue_class:, period:, subtotal:, tax:, total:, tip:, tender:, items:)
+        return unless Database.connected?
+
+        location_id = SkytabSandboxSimulator.configuration.location_id
+
+        order = Models::SimulatedOrder.create!(
+          skytab_ticket_id: ticket_id,
+          skytab_location_id: location_id,
+          status: "closed",
+          business_date: Date.today,
+          subtotal: subtotal,
+          tax_amount: tax,
+          tip_amount: tip,
+          discount_amount: 0,
+          total: total,
+          revenue_class: revenue_class,
+          meal_period: period.to_s,
+          metadata: { pos_ref: pos_ref, items: items.map { |i| i["name"] } }
+        )
+
+        Models::SimulatedPayment.create!(
+          simulated_order: order,
+          skytab_payment_id: "PAY-#{SecureRandom.hex(6).upcase}",
+          tender_name: tender,
+          amount: total,
+          tip_amount: tip,
+          tax_amount: tax,
+          status: "completed",
+          payment_type: tender == "CASH" ? "cash" : "card"
+        )
+      rescue StandardError => e
+        logger.debug "Failed to persist order: #{e.message}"
+      end
+
+      def determine_order_count
+        day = Date.today.wday
+        pattern = case day
+                  when 5 then ORDER_PATTERNS[:friday]
+                  when 6 then ORDER_PATTERNS[:saturday]
+                  when 0 then ORDER_PATTERNS[:sunday]
+                  else ORDER_PATTERNS[:weekday]
+                  end
+        rand(pattern[:min]..pattern[:max])
+      end
+
+      def select_meal_period
+        total_weight = MEAL_PERIODS.values.sum { |v| v[:weight] }
+        roll = rand(total_weight)
+        cumulative = 0
+
+        MEAL_PERIODS.each do |period, config|
+          cumulative += config[:weight]
+          return period if roll < cumulative
+        end
+
+        :dinner
+      end
+
+      def select_revenue_class(period)
+        dist = REVENUE_CLASS_BY_PERIOD[period]
+        total_weight = dist.values.sum
+        roll = rand(total_weight)
+        cumulative = 0
+
+        dist.each do |revenue_class, weight|
+          cumulative += weight
+          return revenue_class if roll < cumulative
+        end
+
+        "DINE_IN"
+      end
+
+      def select_tender
+        total_weight = TENDER_WEIGHTS.values.sum
+        roll = rand(total_weight)
+        cumulative = 0
+
+        TENDER_WEIGHTS.each do |tender, weight|
+          cumulative += weight
+          return tender if roll < cumulative
+        end
+
+        "VISA"
+      end
+
+      def calculate_tip(total, revenue_class)
+        rates = TIP_RATES[revenue_class] || TIP_RATES["DINE_IN"]
+        tip_pct = rand(rates[:min]..rates[:max])
+        (total * tip_pct / 100.0).round
+      end
+
+      def update_stats(order, period)
+        return unless order
+
+        @stats[:orders] += 1
+        @stats[:revenue] += order["total"] || 0
+        @stats[:tips] += order["tip"] || 0
+        @stats[:tax] += order["tax"] || 0
+        @stats[:by_period][period] += 1
+        @stats[:by_revenue_class][order["revenueClassPosRef"]] += 1
+
+        tender = order.dig("payments", 0, "tenderPosRef")
+        @stats[:by_tender][tender] += 1 if tender
+      end
+
+      def print_summary
+        logger.info "=" * 50
+        logger.info "Order Generation Summary"
+        logger.info "=" * 50
+        logger.info "  Total orders:  #{@stats[:orders]}"
+        logger.info "  Revenue:       $#{(@stats[:revenue] / 100.0).round(2)}"
+        logger.info "  Tips:          $#{(@stats[:tips] / 100.0).round(2)}"
+        logger.info "  Tax:           $#{(@stats[:tax] / 100.0).round(2)}"
+
+        if @stats[:by_period].any?
+          logger.info ""
+          logger.info "  By Period:"
+          @stats[:by_period].each { |p, c| logger.info "    #{p}: #{c}" }
+        end
+
+        if @stats[:by_revenue_class].any?
+          logger.info ""
+          logger.info "  By Revenue Class:"
+          @stats[:by_revenue_class].each { |rc, c| logger.info "    #{rc}: #{c}" }
+        end
+
+        if @stats[:by_tender].any?
+          logger.info ""
+          logger.info "  By Tender:"
+          @stats[:by_tender].each { |t, c| logger.info "    #{t}: #{c}" }
+        end
+      end
+    end
+  end
+

data/lib/skytab_sandbox_simulator/models/api_request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Models
+    class ApiRequest < Record
+      # Validations
+      validates :http_method, presence: true
+      validates :url, presence: true
+
+      # Time scopes
+      scope :today, -> { where("created_at >= ?", Time.now.utc.beginning_of_day) }
+      scope :recent, ->(minutes = 60) { where("created_at >= ?", minutes.minutes.ago) }
+
+      # Status scopes
+      scope :errors, -> { where("response_status >= 400 OR error_message IS NOT NULL") }
+      scope :successful, -> { where("response_status < 400 AND error_message IS NULL") }
+
+      # Resource scopes
+      scope :for_resource, ->(type) { where(resource_type: type) }
+      scope :for_resource_id, ->(type, id) { where(resource_type: type, resource_id: id) }
+
+      # Location scope
+      scope :for_location, ->(location_id) {
+        sanitized = sanitize_sql_like(location_id)
+        where("url LIKE ?", "%/#{sanitized}/%")
+          .or(where("url LIKE ?", "%/#{sanitized}"))
+      }
+
+      # HTTP method scopes
+      scope :gets, -> { where(http_method: "GET") }
+      scope :posts, -> { where(http_method: "POST") }
+      scope :puts, -> { where(http_method: "PUT") }
+      scope :deletes, -> { where(http_method: "DELETE") }
+
+      # Performance
+      scope :slow, ->(threshold_ms = 1000) { where("duration_ms > ?", threshold_ms) }
+
+      def error?
+        error_message.present? || (response_status && response_status >= 400)
+      end
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/models/business_type.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Models
+    class BusinessType < Record
+      has_many :categories, dependent: :destroy
+      has_many :items, through: :categories
+      has_many :simulated_orders, dependent: :nullify
+
+      # Validations
+      validates :key, presence: true, uniqueness: true
+      validates :name, presence: true
+
+      # Scopes by industry
+      scope :food_types, -> { where(industry: "food") }
+      scope :retail_types, -> { where(industry: "retail") }
+      scope :service_types, -> { where(industry: "service") }
+
+      # Find by key (the primary lookup pattern)
+      def self.find_by_key!(key)
+        find_by!(key: key)
+      end
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/models/category.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Models
+    class Category < Record
+      belongs_to :business_type
+      has_many :items, dependent: :destroy
+
+      # Validations
+      validates :name, presence: true
+
+      # Explicit sort scope
+      scope :sorted, -> { order(:sort_order) }
+      scope :with_items, -> { joins(:items).distinct }
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/models/daily_summary.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Models
+    class DailySummary < Record
+      # Validations
+      validates :location_id, presence: true
+      validates :business_date, presence: true,
+                                uniqueness: { scope: :location_id }
+
+      # Scopes
+      scope :for_location, ->(location_id) { where(location_id: location_id) }
+      scope :on_date, ->(date) { where(business_date: date) }
+      scope :today, -> { where(business_date: Date.today) }
+      scope :between_dates, ->(from, to) { where(business_date: from..to) }
+      scope :recent, ->(days = 7) { where("business_date >= ?", days.days.ago.to_date) }
+
+      # Generate (or update) a daily summary by aggregating simulated orders.
+      # Race-condition safe: retries on unique constraint violation.
+      #
+      # @param location_id [String] SkyTab location ID
+      # @param date [Date] Business date to summarize
+      # @return [DailySummary] the created or updated summary
+      def self.generate_for!(location_id, date)
+        orders = SimulatedOrder.for_location(location_id).on_date(date).successful
+        payments = SimulatedPayment.joins(:simulated_order)
+                                   .where(simulated_orders: {
+                                     skytab_location_id: location_id,
+                                     business_date: date,
+                                     status: "closed"
+                                   })
+
+        # Build breakdown by revenue class and meal period
+        breakdown = {
+          by_meal_period: orders.group(:meal_period).count,
+          by_revenue_class: orders.group(:revenue_class).count,
+          by_tender: payments.group(:tender_name).count,
+          revenue_by_meal_period: orders.group(:meal_period).sum(:total),
+          revenue_by_revenue_class: orders.group(:revenue_class).sum(:total)
+        }
+
+        attrs = {
+          order_count: orders.count,
+          payment_count: payments.count,
+          refund_count: SimulatedOrder.for_location(location_id).on_date(date).refunded.count,
+          total_revenue: orders.sum(:total),
+          total_tax: orders.sum(:tax_amount),
+          total_tips: orders.sum(:tip_amount),
+          total_discounts: orders.sum(:discount_amount),
+          breakdown: breakdown
+        }
+
+        summary = find_or_initialize_by(location_id: location_id, business_date: date)
+        summary.assign_attributes(attrs)
+        summary.save!
+        summary
+      rescue ::ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      # Convenience: total revenue in dollars
+      def total_revenue_dollars
+        (total_revenue || 0) / 100.0
+      end
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/models/item.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Models
+    class Item < Record
+      belongs_to :category
+
+      # Validations
+      validates :name, presence: true
+      validates :price, presence: true,
+                        numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+      # Scopes
+      scope :active, -> { where(active: true) }
+      scope :inactive, -> { where(active: false) }
+
+      scope :for_business_type, ->(key) {
+        joins(category: :business_type)
+          .where(business_types: { key: key })
+      }
+
+      scope :in_category, ->(category_name) {
+        joins(:category).where(categories: { name: category_name })
+      }
+
+      # Price in dollars (convenience)
+      def price_dollars
+        (price || 0) / 100.0
+      end
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/models/record.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module SkytabSandboxSimulator
+  module Models
+    # Shared base class for all simulator ActiveRecord models.
+    #
+    # Equivalent to ApplicationRecord in Rails, but for standalone usage.
+    class Record < ::ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/models/simulated_order.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Models
+    class SimulatedOrder < Record
+      belongs_to :business_type, optional: true
+      has_many :simulated_payments, dependent: :destroy
+
+      # Validations
+      validates :skytab_location_id, presence: true
+      validates :status, presence: true
+      validates :business_date, presence: true
+
+      # Status scopes
+      scope :successful, -> { where(status: "closed") }
+      scope :open_orders, -> { where(status: "open") }
+      scope :refunded, -> { where(status: "refunded") }
+      scope :voided, -> { where(status: "voided") }
+
+      # Time scopes
+      scope :today, -> { where(business_date: Date.today) }
+      scope :on_date, ->(date) { where(business_date: date) }
+      scope :between_dates, ->(from, to) { where(business_date: from..to) }
+
+      # Filter scopes
+      scope :for_location, ->(location_id) { where(skytab_location_id: location_id) }
+      scope :for_revenue_class, ->(revenue_class) { where(revenue_class: revenue_class) }
+      scope :for_meal_period, ->(period) { where(meal_period: period) }
+
+      # Amounts in dollars (convenience)
+      def total_dollars
+        (total || 0) / 100.0
+      end
+
+      def subtotal_dollars
+        (subtotal || 0) / 100.0
+      end
+    end
+  end
+end

data/lib/skytab_sandbox_simulator/models/simulated_payment.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SkytabSandboxSimulator
+  module Models
+    class SimulatedPayment < Record
+      belongs_to :simulated_order
+
+      # Validations
+      validates :tender_name, presence: true
+      validates :status, presence: true
+      validates :amount, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+      # Status scopes
+      scope :successful, -> { where(status: "completed") }
+      scope :pending, -> { where(status: "pending") }
+      scope :refunded, -> { where(status: "refunded") }
+
+      # Tender scopes
+      scope :cash, -> { where(tender_name: "Cash") }
+      scope :by_tender, ->(name) { where(tender_name: name) }
+
+      # Amount in dollars (convenience)
+      def amount_dollars
+        (amount || 0) / 100.0
+      end
+    end
+  end
+end