revel_sandbox_simulator 0.1.0

data/lib/revel_sandbox_simulator/generators/order_generator.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Generators
+    class OrderGenerator
+      MEAL_PERIODS = {
+        breakfast: { start_hour: 7, end_hour: 10, weight: 15 },
+        lunch: { start_hour: 11, end_hour: 14, weight: 30 },
+        happy_hour: { start_hour: 15, end_hour: 17, weight: 10 },
+        dinner: { start_hour: 17, end_hour: 21, weight: 35 },
+        late_night: { start_hour: 21, end_hour: 23, weight: 10 }
+      }.freeze
+
+      DINING_BY_PERIOD = {
+        breakfast: { dine_in: 40, takeout: 50, delivery: 10 },
+        lunch: { dine_in: 35, takeout: 45, delivery: 20 },
+        happy_hour: { dine_in: 80, takeout: 15, delivery: 5 },
+        dinner: { dine_in: 70, takeout: 15, delivery: 15 },
+        late_night: { dine_in: 50, takeout: 30, delivery: 20 }
+      }.freeze
+
+      ORDER_PATTERNS = {
+        monday: { min: 40, max: 60 },
+        tuesday: { min: 40, max: 60 },
+        wednesday: { min: 40, max: 60 },
+        thursday: { min: 40, max: 60 },
+        friday: { min: 70, max: 100 },
+        saturday: { min: 80, max: 120 },
+        sunday: { min: 50, max: 80 }
+      }.freeze
+
+      TIP_RATES = {
+        dine_in: { chance: 70, min: 15, max: 25 },
+        takeout: { chance: 20, min: 5, max: 15 },
+        delivery: { chance: 50, min: 10, max: 20 }
+      }.freeze
+
+      ITEMS_PER_PERIOD = {
+        breakfast: { min: 1, max: 3 },
+        lunch: { min: 2, max: 4 },
+        happy_hour: { min: 2, max: 4 },
+        dinner: { min: 3, max: 6 },
+        late_night: { min: 1, max: 3 }
+      }.freeze
+
+      attr_reader :config, :services, :data_loader, :refund_percentage
+
+      def initialize(config: nil, services: nil, refund_percentage: 5)
+        @config = config || RevelSandboxSimulator.configuration
+        @services = services || Services::Revel::ServicesManager.new(config: @config)
+        @data_loader = DataLoader.new(config: @config)
+        @refund_percentage = refund_percentage
+      end
+
+      def generate_today(count: nil)
+        count ||= daily_order_count
+        RevelSandboxSimulator.logger.info("Generating #{count} orders for today...")
+
+        products = load_products
+        tenders = data_loader.load_tenders
+
+        period_counts = distribute_across_periods(count)
+        orders = []
+
+        period_counts.each do |period, period_count|
+          period_count.times do
+            order = generate_single_order(products, tenders, period: period)
+            orders << order if order
+          end
+        end
+
+        process_refunds(orders) if refund_percentage.positive?
+        generate_summary
+
+        RevelSandboxSimulator.logger.info("Generated #{orders.size} orders")
+        orders
+      end
+
+      def generate_realistic_day(multiplier: 1.0)
+        count = (daily_order_count * multiplier).round
+        generate_today(count: count)
+      end
+
+      def generate_rush(period:, count: 15)
+        products = load_products
+        tenders = data_loader.load_tenders
+
+        count.times.filter_map do
+          generate_single_order(products, tenders, period: period.to_sym)
+        end
+      end
+
+      def daily_order_count
+        day = Date.today.strftime("%A").downcase.to_sym
+        pattern = ORDER_PATTERNS.fetch(day, ORDER_PATTERNS[:monday])
+        rand(pattern[:min]..pattern[:max])
+      end
+
+      def distribute_across_periods(total_count)
+        total_weight = MEAL_PERIODS.values.sum { |p| p[:weight] }
+        MEAL_PERIODS.each_with_object({}) do |(period, data), hash|
+          hash[period] = ((data[:weight].to_f / total_weight) * total_count).round
+        end
+      end
+
+      private
+
+      def load_products
+        data_loader.load_items
+      end
+
+      def generate_single_order(products, tenders, period:)
+        dining_option = weighted_select(DINING_BY_PERIOD[period])
+        item_count_range = ITEMS_PER_PERIOD[period]
+        item_count = rand(item_count_range[:min]..item_count_range[:max])
+        selected_items = products.sample(item_count)
+
+        return nil if selected_items.empty?
+
+        subtotal = selected_items.sum { |i| i[:price] }
+        discount = calculate_discount(subtotal)
+        tax = calculate_tax(subtotal - discount)
+        tip = calculate_tip(subtotal, dining_option)
+        total = subtotal - discount + tax + tip
+
+        tender = select_tender(tenders)
+        payment_type = tender_to_payment_type(tender)
+
+        items_payload = selected_items.map do |item|
+          { product_id: item[:sku] || item[:name], quantity: 1, unit_price: item[:price] }
+        end
+
+        result = services.order.create_order(
+          items: items_payload,
+          dining_option: dining_option,
+          discount_amount: discount
+        )
+
+        order_id = result["id"]
+
+        services.payment.create_payment(
+          order_id: order_id,
+          amount: total,
+          payment_type: payment_type,
+          tip_amount: tip
+        )
+
+        persist_order(result, period, dining_option, subtotal, tax, tip, discount, total, tender, payment_type)
+
+        result
+      rescue ApiError => e
+        RevelSandboxSimulator.logger.warn("Order generation failed: #{e.message}")
+        nil
+      end
+
+      def persist_order(result, period, dining_option, subtotal, tax, tip, discount, total, tender, payment_type)
+        return unless Database.connected?
+
+        order = Models::SimulatedOrder.create!(
+          revel_order_id: result["id"] || SecureRandom.uuid,
+          status: "paid",
+          business_date: Date.today,
+          dining_option: dining_option.to_s,
+          meal_period: period.to_s,
+          subtotal: subtotal,
+          tax_amount: tax,
+          tip_amount: tip,
+          discount_amount: discount,
+          total: total,
+          metadata: { source: "simulator" }
+        )
+
+        Models::SimulatedPayment.create!(
+          simulated_order: order,
+          revel_payment_id: SecureRandom.uuid,
+          tender_name: tender || "Credit Card",
+          amount: total,
+          tip_amount: tip,
+          tax_amount: tax,
+          status: "success",
+          payment_type: payment_type.to_s
+        )
+      rescue StandardError
+        nil
+      end
+
+      def weighted_select(weights)
+        total = weights.values.sum
+        roll = rand(total)
+        cumulative = 0
+
+        weights.each do |key, weight|
+          cumulative += weight
+          return key if roll < cumulative
+        end
+
+        weights.keys.last
+      end
+
+      def select_tender(tenders)
+        return "Credit Card" if tenders.nil? || tenders.empty?
+
+        weights = tenders.to_h { |t| [t["name"], t["weight"] || 1] }
+        weighted_select(weights)
+      end
+
+      def tender_to_payment_type(tender_name)
+        case tender_name&.downcase
+        when "cash" then :cash
+        when "debit card" then :debit_card
+        when "gift card" then :gift_card
+        when "check" then :check
+        when "mobile pay" then :mobile_pay
+        else :credit_card
+        end
+      end
+
+      def calculate_discount(subtotal)
+        return 0 if rand(100) >= 8
+
+        percentage = rand(10..20)
+        (subtotal * percentage / 100.0).round
+      end
+
+      def calculate_tip(subtotal, dining_option)
+        rates = TIP_RATES.fetch(dining_option.to_sym, TIP_RATES[:dine_in])
+        return 0 if rand(100) >= rates[:chance]
+
+        percentage = rand(rates[:min]..rates[:max])
+        (subtotal * percentage / 100.0).round
+      end
+
+      def calculate_tax(taxable_amount)
+        (taxable_amount * config.tax_rate / 100.0).round
+      end
+
+      def process_refunds(orders)
+        return if orders.empty?
+
+        refund_count = (orders.size * refund_percentage / 100.0).ceil
+        orders.sample(refund_count).each do |order|
+          next unless Database.connected?
+
+          simulated = Models::SimulatedOrder.find_by(revel_order_id: order["id"])
+          simulated&.update!(status: "refunded")
+        end
+      rescue StandardError
+        nil
+      end
+
+      def generate_summary
+        return unless Database.connected?
+
+        Models::DailySummary.generate_for!(Date.today)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/api_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class ApiRequest < Record
+      scope :errors, -> { where.not(error_message: nil) }
+      scope :by_resource, ->(type) { where(resource_type: type) }
+      scope :recent, -> { order(created_at: :desc) }
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/business_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class BusinessType < Record
+      has_many :categories, dependent: :destroy
+      has_many :items, dependent: :destroy
+
+      validates :key, presence: true, uniqueness: true
+      validates :name, presence: true
+      validates :industry, presence: true
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/category.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class Category < Record
+      belongs_to :business_type
+      has_many :items, dependent: :destroy
+
+      validates :name, presence: true, uniqueness: { scope: :business_type_id }
+      validates :sort_order, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+
+      scope :for_business_type, ->(bt) { where(business_type: bt) }
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/daily_summary.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class DailySummary < Record
+      validates :summary_date, presence: true, uniqueness: true
+
+      def self.generate_for!(date)
+        orders = SimulatedOrder.for_date(date)
+        payments = SimulatedPayment.where(simulated_order: orders).successful
+
+        breakdown = {
+          by_meal_period: build_meal_period_breakdown(orders),
+          by_dining_option: build_dining_option_breakdown(orders),
+          by_tender: build_tender_breakdown(payments)
+        }
+
+        find_or_initialize_by(summary_date: date).tap do |summary|
+          summary.update!(
+            order_count: orders.count,
+            payment_count: payments.count,
+            refund_count: orders.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
+          )
+        end
+      end
+
+      def self.build_meal_period_breakdown(orders)
+        %w[breakfast lunch happy_hour dinner late_night].each_with_object({}) do |period, hash|
+          period_orders = orders.for_meal_period(period)
+          hash[period] = { count: period_orders.count, revenue: period_orders.sum(:total) }
+        end
+      end
+
+      def self.build_dining_option_breakdown(orders)
+        %w[dine_in takeout delivery].each_with_object({}) do |option, hash|
+          option_orders = orders.where(dining_option: option)
+          hash[option] = { count: option_orders.count, revenue: option_orders.sum(:total) }
+        end
+      end
+
+      def self.build_tender_breakdown(payments)
+        payments.group(:tender_name).sum(:amount).transform_values(&:to_i)
+      end
+
+      private_class_method :build_meal_period_breakdown, :build_dining_option_breakdown, :build_tender_breakdown
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/item.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class Item < Record
+      belongs_to :business_type
+      belongs_to :category, optional: true
+
+      validates :name, presence: true
+      validates :price, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :sku, uniqueness: true, allow_nil: true
+
+      scope :for_business_type, ->(bt) { where(business_type: bt) }
+      scope :for_category, ->(cat) { where(category: cat) }
+      scope :by_price, -> { order(:price) }
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/record.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class Record < ActiveRecord::Base
+      self.abstract_class = true
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/simulated_order.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class SimulatedOrder < Record
+      has_many :simulated_payments, dependent: :destroy
+
+      validates :revel_order_id, presence: true, uniqueness: true
+      validates :status, presence: true, inclusion: { in: %w[open paid refunded voided] }
+      validates :dining_option, presence: true, inclusion: { in: %w[dine_in takeout delivery] }
+      validates :meal_period, presence: true,
+                              inclusion: { in: %w[breakfast lunch happy_hour dinner late_night] }
+
+      scope :paid, -> { where(status: "paid") }
+      scope :refunded, -> { where(status: "refunded") }
+      scope :for_date, ->(date) { where(business_date: date) }
+      scope :for_meal_period, ->(period) { where(meal_period: period) }
+    end
+  end
+end

data/lib/revel_sandbox_simulator/models/simulated_payment.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Models
+    class SimulatedPayment < Record
+      belongs_to :simulated_order
+
+      validates :simulated_order, presence: true
+      validates :tender_name, presence: true
+      validates :amount, presence: true, numericality: { greater_than_or_equal_to: 0 }
+      validates :status, presence: true, inclusion: { in: %w[pending success failed] }
+
+      scope :successful, -> { where(status: "success") }
+    end
+  end
+end

data/lib/revel_sandbox_simulator/seeder.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  class Seeder
+    SEED_MAP = {
+      restaurant: {
+        industry: "food",
+        categories: {
+          "Appetizers" => ["Buffalo Wings", "Mozzarella Sticks", "Calamari", "Bruschetta", "Spinach Dip"],
+          "Entrees" => ["NY Strip Steak", "Grilled Salmon", "Chicken Parmesan", "Lamb Chops", "Shrimp Pasta"],
+          "Sides" => ["Caesar Salad", "Mashed Potatoes", "Grilled Vegetables", "French Fries", "Coleslaw"],
+          "Beverages" => ["Soft Drink", "Iced Tea", "Lemonade", "Coffee", "Sparkling Water"],
+          "Desserts" => ["Chocolate Cake", "Tiramisu", "Cheesecake", "Creme Brulee", "Apple Pie"]
+        }
+      },
+      cafe_bakery: {
+        industry: "food",
+        categories: {
+          "Hot Drinks" => ["Espresso", "Cappuccino", "Latte", "Americano", "Hot Chocolate"],
+          "Cold Drinks" => ["Iced Coffee", "Cold Brew", "Iced Latte", "Smoothie", "Lemonade"],
+          "Pastries" => ["Croissant", "Muffin", "Scone", "Danish", "Cinnamon Roll"],
+          "Sandwiches" => ["Avocado Toast", "BLT", "Turkey Club", "Grilled Cheese", "Veggie Wrap"],
+          "Cakes" => ["Chocolate Cake", "Red Velvet", "Carrot Cake", "Lemon Tart", "Brownie"]
+        }
+      },
+      bar_nightclub: {
+        industry: "food",
+        categories: {
+          "Draft Beer" => ["IPA Pint", "Lager Pint", "Stout Pint", "Wheat Beer", "Pale Ale"],
+          "Cocktails" => ["Margarita", "Old Fashioned", "Mojito", "Cosmopolitan", "Manhattan"],
+          "Wine" => ["House Red Wine", "House White Wine", "Rose", "Prosecco", "Pinot Noir"],
+          "Spirits" => ["Whiskey Shot", "Vodka Shot", "Tequila Shot", "Rum Shot", "Gin Shot"],
+          "Bar Food" => ["Loaded Nachos", "Chicken Wings", "Sliders", "Fries Basket", "Pretzel Bites"]
+        }
+      },
+      retail_general: {
+        industry: "retail",
+        categories: {
+          "Electronics" => ["Phone Charger", "USB Cable", "Earbuds", "Power Bank", "Screen Protector"],
+          "Clothing" => %w[T-Shirt Hoodie Cap Socks Belt],
+          "Home & Garden" => ["Candle", "Mug", "Plant Pot", "Picture Frame", "Cushion"],
+          "Health & Beauty" => ["Hand Cream", "Lip Balm", "Face Mask", "Shampoo", "Body Wash"],
+          "Groceries" => ["Snack Bar", "Energy Drink", "Water Bottle", "Trail Mix", "Protein Bar"]
+        }
+      }
+    }.freeze
+
+    def seed!(business_type: nil)
+      types_to_seed = business_type ? [business_type.to_sym] : SEED_MAP.keys
+      counts = { business_types: 0, categories: 0, items: 0 }
+
+      types_to_seed.each do |type_key|
+        data = SEED_MAP[type_key]
+        next unless data
+
+        bt = seed_business_type(type_key, data)
+        counts[:business_types] += 1
+
+        data[:categories].each_with_index do |(cat_name, item_names), idx|
+          cat = seed_category(bt, cat_name, idx)
+          counts[:categories] += 1
+
+          item_names.each do |item_name|
+            seed_item(bt, cat, type_key, item_name)
+            counts[:items] += 1
+          end
+        end
+      end
+
+      RevelSandboxSimulator.logger.info("Seeded: #{counts}")
+      counts
+    end
+
+    private
+
+    def seed_business_type(key, data)
+      Models::BusinessType.find_or_create_by!(key: key.to_s) do |bt|
+        bt.name = key.to_s.tr("_", " ").split.map(&:capitalize).join(" ")
+        bt.industry = data[:industry]
+        bt.order_profile = {}
+      end
+    end
+
+    def seed_category(business_type, name, sort_order)
+      Models::Category.find_or_create_by!(business_type: business_type, name: name) do |cat|
+        cat.sort_order = sort_order
+      end
+    end
+
+    def seed_item(business_type, category, type_key, item_name)
+      loader = Generators::DataLoader.new(config: build_config(type_key))
+      items_json = loader.load_items
+      json_item = items_json.find { |i| i[:name] == item_name }
+      price = json_item ? json_item[:price] : rand(299..2999)
+
+      Models::Item.find_or_create_by!(business_type: business_type, name: item_name) do |item|
+        item.category = category
+        item.price = price
+        item.sku = generate_sku(type_key, item_name)
+      end
+    end
+
+    def generate_sku(type_key, item_name)
+      prefix = type_key.to_s[0..2].upcase
+      suffix = item_name.gsub(/[^a-zA-Z0-9]/, "")[0..5].upcase
+      "#{prefix}-#{suffix}-#{SecureRandom.hex(2).upcase}"
+    end
+
+    def build_config(type_key)
+      config = Configuration.new
+      config.business_type = type_key
+      config
+    end
+  end
+end

data/lib/revel_sandbox_simulator/services/base_service.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "rest-client"
+require "json"
+require "securerandom"
+
+module RevelSandboxSimulator
+  module Services
+    class BaseService
+      DEFAULT_LIMIT = 50
+      MAX_LIMIT = 200
+
+      attr_reader :config
+
+      def initialize(config: nil)
+        @config = config || RevelSandboxSimulator.configuration
+      end
+
+      protected
+
+      def request(method, path, payload: nil, params: {}, resource_type: nil, resource_id: nil)
+        url = build_url(path, params)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        response = execute_request(method, url, payload)
+        parsed = parse_response(response)
+
+        duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+        audit_api_request(method, url, payload, response.code, parsed, duration, nil, resource_type, resource_id)
+
+        parsed
+      rescue RestClient::ExceptionWithResponse => e
+        duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+        error_body = parse_response(e.response)
+        error_message = extract_error_message(e, error_body)
+        audit_api_request(method, url, payload, e.http_code, error_body, duration, error_message, resource_type, resource_id)
+        raise ApiError, "#{method.upcase} #{path} failed (#{e.http_code}): #{error_message}"
+      rescue StandardError => e
+        raise ApiError, "#{method.upcase} #{path} failed: #{e.message}" unless e.is_a?(ApiError)
+
+        raise
+      end
+
+      def fetch_all_pages(path, params: {})
+        all_objects = []
+        offset = 0
+        limit = params.delete(:limit) || DEFAULT_LIMIT
+
+        loop do
+          page_params = params.merge(offset: offset, limit: limit)
+          result = request(:get, path, params: page_params)
+
+          objects = result["objects"] || []
+          all_objects.concat(objects)
+
+          meta = result["meta"] || {}
+          break if meta["next"].nil? || objects.empty?
+
+          offset += limit
+        end
+
+        all_objects
+      end
+
+      def build_url(path, params = {})
+        url = "#{config.base_url}/#{path}"
+        url += "?#{URI.encode_www_form(params)}" unless params.empty?
+        url
+      end
+
+      def execute_request(method, url, payload)
+        args = {
+          method: method,
+          url: url,
+          headers: request_headers(payload)
+        }
+        args[:payload] = payload.to_json if payload
+
+        RestClient::Request.execute(**args)
+      end
+
+      def request_headers(payload = nil)
+        headers = {
+          "API-AUTHENTICATION" => config.auth_header,
+          accept: :json
+        }
+        headers[:content_type] = :json if payload
+        headers
+      end
+
+      def parse_response(response)
+        return {} if response.nil? || response.body.nil? || response.body.empty?
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        { "raw" => response.body }
+      end
+
+      def extract_error_message(error, parsed_body)
+        if parsed_body.is_a?(Hash)
+          parsed_body["error"] || parsed_body["detail"] || parsed_body["message"] || error.message
+        else
+          error.message
+        end
+      end
+
+      def audit_api_request(method, url, request_payload, status, response_payload, duration, error, resource_type, resource_id)
+        return unless Database.connected?
+
+        Models::ApiRequest.create!(
+          http_method: method.to_s.upcase,
+          url: url,
+          request_payload: request_payload,
+          response_status: status,
+          response_payload: response_payload,
+          duration_ms: duration,
+          error_message: error,
+          resource_type: resource_type,
+          resource_id: resource_id&.to_s
+        )
+      rescue StandardError
+        nil
+      end
+
+      def with_api_fallback(fallback: nil, log_level: :warn)
+        yield
+      rescue ApiError => e
+        RevelSandboxSimulator.logger.send(log_level, e.message)
+        fallback
+      end
+
+      def safe_dig(hash, *keys, default: nil)
+        result = hash
+        keys.each do |key|
+          return default unless result.is_a?(Hash)
+
+          result = result[key]
+        end
+        result || default
+      end
+    end
+  end
+end