revel_sandbox_simulator 0.1.0

data/lib/revel_sandbox_simulator/services/revel/customer_service.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Services
+    module Revel
+      class CustomerService < BaseService
+        CUSTOMER_PATH = "resources/Customer/"
+
+        def fetch_customers
+          fetch_all_pages(CUSTOMER_PATH)
+        end
+
+        def get_customer(id)
+          request(:get, "#{CUSTOMER_PATH}#{id}/", resource_type: "Customer", resource_id: id)
+        end
+
+        def create_customer(first_name:, last_name:, email: nil, phone: nil)
+          payload = {
+            first_name: first_name,
+            last_name: last_name,
+            email: email,
+            phone_number: phone
+          }
+
+          request(:post, CUSTOMER_PATH, payload: payload.compact, resource_type: "Customer")
+        end
+
+        def find_customer_by_email(email)
+          result = request(:get, CUSTOMER_PATH, params: { email: email, limit: 1 })
+          objects = result["objects"] || []
+          objects.first
+        end
+
+        def ensure_customers(count: 20)
+          existing = fetch_customers
+          needed = count - existing.size
+          return existing if needed <= 0
+
+          created = needed.times.map do |i|
+            create_customer(
+              first_name: Faker::Name.first_name,
+              last_name: Faker::Name.last_name,
+              email: "customer#{existing.size + i + 1}@example.com",
+              phone: Faker::PhoneNumber.phone_number
+            )
+          end
+
+          existing + created
+        end
+      end
+    end
+  end
+end

data/lib/revel_sandbox_simulator/services/revel/establishment_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Services
+    module Revel
+      class EstablishmentService < BaseService
+        ESTABLISHMENT_PATH = "enterprise/Establishment/"
+
+        def fetch_establishments
+          fetch_all_pages(ESTABLISHMENT_PATH)
+        end
+
+        def get_establishment(id)
+          request(:get, "#{ESTABLISHMENT_PATH}#{id}/", resource_type: "Establishment", resource_id: id)
+        end
+      end
+    end
+  end
+end

data/lib/revel_sandbox_simulator/services/revel/order_service.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Services
+    module Revel
+      class OrderService < BaseService
+        ORDER_PATH = "resources/Order/"
+        ORDER_ITEM_PATH = "resources/OrderItem/"
+
+        DINING_OPTIONS = {
+          dine_in: 0,
+          takeout: 1,
+          delivery: 2
+        }.freeze
+
+        def fetch_orders(params: {})
+          fetch_all_pages(ORDER_PATH, params: params)
+        end
+
+        def get_order(id)
+          request(:get, "#{ORDER_PATH}#{id}/", resource_type: "Order", resource_id: id)
+        end
+
+        def create_order(items:, dining_option: :dine_in, discount_amount: 0, establishment_id: nil)
+          est_id = establishment_id || config.establishment_id
+          payload = {
+            establishment: "/enterprise/Establishment/#{est_id}/",
+            dining_option: DINING_OPTIONS.fetch(dining_option.to_sym, 0),
+            discount: format("%.2f", discount_amount / 100.0),
+            orderInfo_id: SecureRandom.uuid
+          }
+
+          result = request(:post, ORDER_PATH, payload: payload, resource_type: "Order")
+          order_id = extract_id(result)
+
+          items.each do |item|
+            create_order_item(order_id: order_id, product_id: item[:product_id],
+                              quantity: item.fetch(:quantity, 1), unit_price: item[:unit_price])
+          end
+
+          result.merge("id" => order_id, "items_created" => items.size)
+        end
+
+        def create_order_item(order_id:, product_id:, quantity: 1, unit_price: nil)
+          payload = {
+            order: "/resources/Order/#{order_id}/",
+            product: "/resources/Product/#{product_id}/",
+            quantity: quantity
+          }
+          payload[:price] = format("%.2f", unit_price / 100.0) if unit_price
+
+          request(:post, ORDER_ITEM_PATH, payload: payload, resource_type: "OrderItem")
+        end
+
+        def fetch_orders_by_date(start_date:, end_date: nil)
+          end_date ||= start_date
+          params = {
+            created_date__gte: start_date.to_s,
+            created_date__lte: "#{end_date}T23:59:59"
+          }
+          fetch_orders(params: params)
+        end
+
+        private
+
+        def extract_id(result)
+          return result["id"] if result["id"]
+
+          uri = result["resource_uri"]
+          return nil unless uri
+
+          uri.split("/").reject(&:empty?).last
+        end
+      end
+    end
+  end
+end

data/lib/revel_sandbox_simulator/services/revel/payment_service.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Services
+    module Revel
+      class PaymentService < BaseService
+        PAYMENT_PATH = "resources/Payment/"
+
+        PAYMENT_TYPES = {
+          cash: 0,
+          credit_card: 1,
+          debit_card: 2,
+          gift_card: 3,
+          check: 4,
+          mobile_pay: 5
+        }.freeze
+
+        def fetch_payments(params: {})
+          fetch_all_pages(PAYMENT_PATH, params: params)
+        end
+
+        def get_payment(id)
+          request(:get, "#{PAYMENT_PATH}#{id}/", resource_type: "Payment", resource_id: id)
+        end
+
+        def create_payment(order_id:, amount:, payment_type: :credit_card, tip_amount: 0)
+          payload = {
+            order: "/resources/Order/#{order_id}/",
+            amount: format("%.2f", amount / 100.0),
+            tip: format("%.2f", tip_amount / 100.0),
+            type: PAYMENT_TYPES.fetch(payment_type.to_sym, 1)
+          }
+
+          request(:post, PAYMENT_PATH, payload: payload, resource_type: "Payment")
+        end
+
+        def create_cash_payment(order_id:, amount:, tip_amount: 0)
+          create_payment(order_id: order_id, amount: amount, payment_type: :cash, tip_amount: tip_amount)
+        end
+
+        def refund_payment(payment_id:, amount:, reason: nil)
+          payload = {
+            amount: format("%.2f", -(amount / 100.0).abs),
+            reason: reason || "Refund"
+          }
+
+          request(:post, PAYMENT_PATH, payload: payload, resource_type: "Payment", resource_id: payment_id)
+        end
+      end
+    end
+  end
+end

data/lib/revel_sandbox_simulator/services/revel/product_service.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Services
+    module Revel
+      class ProductService < BaseService
+        CATEGORY_PATH = "products/ProductCategory/"
+        PRODUCT_PATH = "resources/Product/"
+
+        def fetch_categories
+          fetch_all_pages(CATEGORY_PATH)
+        end
+
+        def get_category(id)
+          request(:get, "#{CATEGORY_PATH}#{id}/", resource_type: "ProductCategory", resource_id: id)
+        end
+
+        def create_category(name:, description: nil, sort_order: 0, parent_id: nil)
+          payload = {
+            name: name,
+            description: description,
+            sorting: sort_order
+          }
+          payload[:parent] = parent_id if parent_id
+
+          request(:post, CATEGORY_PATH, payload: payload, resource_type: "ProductCategory")
+        end
+
+        def update_category(id, attributes)
+          request(:patch, "#{CATEGORY_PATH}#{id}/", payload: attributes, resource_type: "ProductCategory", resource_id: id)
+        end
+
+        def find_category_by_name(name)
+          result = request(:get, CATEGORY_PATH, params: { name: name, limit: 1 })
+          objects = result["objects"] || []
+          objects.first
+        end
+
+        def find_or_create_category(name:, description: nil, sort_order: 0)
+          existing = find_category_by_name(name)
+          return existing if existing
+
+          create_category(name: name, description: description, sort_order: sort_order)
+        end
+
+        def fetch_products
+          fetch_all_pages(PRODUCT_PATH)
+        end
+
+        def get_product(id)
+          request(:get, "#{PRODUCT_PATH}#{id}/", resource_type: "Product", resource_id: id)
+        end
+
+        def create_product(name:, price:, category_id: nil, sku: nil, barcode: nil, description: nil, cost_price: 0)
+          payload = {
+            name: name,
+            original_price: format("%.2f", price / 100.0),
+            cost: format("%.2f", cost_price / 100.0),
+            sku: sku,
+            barcode: barcode,
+            description: description
+          }
+          payload[:categories] = ["/products/ProductCategory/#{category_id}/"] if category_id
+
+          request(:post, PRODUCT_PATH, payload: payload.compact, resource_type: "Product")
+        end
+
+        def update_product(id, attributes)
+          request(:patch, "#{PRODUCT_PATH}#{id}/", payload: attributes, resource_type: "Product", resource_id: id)
+        end
+
+        def find_product_by_name(name)
+          result = request(:get, PRODUCT_PATH, params: { name: name, limit: 1 })
+          objects = result["objects"] || []
+          objects.first
+        end
+
+        def find_or_create_product(name:, price:, category_id: nil, sku: nil)
+          existing = find_product_by_name(name)
+          return existing if existing
+
+          create_product(name: name, price: price, category_id: category_id, sku: sku)
+        end
+      end
+    end
+  end
+end

data/lib/revel_sandbox_simulator/services/revel/services_manager.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RevelSandboxSimulator
+  module Services
+    module Revel
+      class ServicesManager
+        attr_reader :config
+
+        def initialize(config: nil)
+          @config = config || RevelSandboxSimulator.configuration
+          @mutex = Mutex.new
+          @services = {}
+        end
+
+        def product
+          thread_safe_service(:product) { ProductService.new(config: config) }
+        end
+
+        def order
+          thread_safe_service(:order) { OrderService.new(config: config) }
+        end
+
+        def payment
+          thread_safe_service(:payment) { PaymentService.new(config: config) }
+        end
+
+        def customer
+          thread_safe_service(:customer) { CustomerService.new(config: config) }
+        end
+
+        def establishment
+          thread_safe_service(:establishment) { EstablishmentService.new(config: config) }
+        end
+
+        private
+
+        def thread_safe_service(key)
+          @mutex.synchronize do
+            @services[key] ||= yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/revel_sandbox_simulator/version.rb

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

data/lib/revel_sandbox_simulator.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "dotenv"
+
+module RevelSandboxSimulator
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ApiError < Error; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    def root
+      File.expand_path("..", __dir__)
+    end
+
+    def logger
+      configuration.logger
+    end
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect("revel_sandbox_simulator" => "RevelSandboxSimulator")
+loader.setup
+
+Dotenv.load if File.exist?(".env")