spree_cm_commissioner 2.13.4 → 2.13.7

data/app/controllers/spree/api/v2/platform/store_credits_controller_decorator.rb

@@ -0,0 +1,35 @@
+module Spree
+  module Api
+    module V2
+      module Platform
+        # Platform::ResourceController#authorize_spree_user only runs CanCan checks when the
+        # request carries a user OAuth token (`spree_current_user.present?`); a bare app
+        # (client_credentials) token skips it entirely by design, and the base permitted-params
+        # list falls back to every column on the model (`json_api_permitted_attributes`). That
+        # would let any app token holding the generic `:admin` doorkeeper scope rewrite
+        # `amount`/`amount_used`/`user_id`/`issuer_tenant_id` etc. directly -- bypassing the
+        # prepaid ledger (cm_prepaid_transactions) and the AdminCredit/ReverseTopUp/Freeze
+        # services that exist to keep it consistent, with no record of who changed what.
+        #
+        # Nothing in this monorepo (docs, internal services, cm-market-app/client) calls this
+        # endpoint -- it's just Spree's default auto-generated CRUD from `resources :store_credits`
+        # in spree_api's routes, not something built for a known consumer. Rather than maintain a
+        # safe-fields allowlist forever (every future Spree::StoreCredit column is a fresh chance
+        # to leak through it), the endpoint is disabled outright: every action 404s, same as an
+        # unrouted path would. The route itself still exists (routes.rb lives in gems/spree_api,
+        # which this repo's decorator-only rule forbids editing directly), so this is done from
+        # our own extension gem instead.
+        module StoreCreditsControllerDecorator
+          def self.prepended(base)
+            # prepend_before_action, not before_action -- runs ahead of the base controller's own
+            # doorkeeper_authorize!/authorize_spree_user checks, so this 404s unconditionally
+            # (same as an unrouted path would) rather than only after an auth check passes.
+            base.prepend_before_action { head :not_found }
+          end
+        end
+      end
+    end
+  end
+end
+
+Spree::Api::V2::Platform::StoreCreditsController.prepend Spree::Api::V2::Platform::StoreCreditsControllerDecorator

data/app/controllers/spree/api/v2/storefront/account/prepaid_balances_controller.rb

@@ -0,0 +1,52 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Account
+          # Endpoint: GET /api/v2/storefront/account/prepaid_balances
+          # Single endpoint for both "my one balance" and "all my balances" -- an optional
+          # ?currency= filters down to one (still an array, just 0-or-1 items), omitted returns
+          # every currency the platform has issued the user. Replaces the old separate
+          # GET account/prepaid (show) + GET account/prepaid_balances (index) pair: #show
+          # couldn't express "no currency given" without an :id segment, and this app's other
+          # index/show split forced the response shape (object vs array) to vary by param, which
+          # is worse than one endpoint with one fixed (array) shape and an optional filter.
+          class PrepaidBalancesController < Spree::Api::V2::ResourceController
+            before_action :require_spree_current_user
+
+            def index
+              if params[:currency].present?
+                currency = params[:currency].to_s.upcase
+                unless Spree::Store.default.supported_currency_codes.include?(currency)
+                  return render_error_payload("unsupported currency: #{currency}")
+                end
+              end
+
+              render_serialized_payload { collection_serializer.new(presented_collection(currency)).serializable_hash }
+            end
+
+            private
+
+            # Platform-issued prepaid credit only (Spree::StoreCredit#platform_prepaid scope) --
+            # storefront is the platform namespace; tenant-issued wallet credit isn't
+            # spendable/visible here. Preferred currency sorted first (matches PrepaidConfig's
+            # supported_currencies order) rather than left in arbitrary DB order -- the client
+            # shouldn't have to inspect is_preferred on every item just to know which one to
+            # show first.
+            def presented_collection(currency)
+              preferred_currency = Spree::Store.default.default_currency
+              credits = spree_current_user.store_credits.platform_prepaid(currency).to_a
+              credits.sort_by! { |credit| credit.currency == preferred_currency ? 0 : 1 }
+
+              credits.map { |credit| SpreeCmCommissioner::PrepaidBalancePresenter.new(credit, preferred_currency) }
+            end
+
+            def collection_serializer
+              Spree::V2::Storefront::PrepaidBalanceSerializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/account/prepaid_transactions_controller.rb

@@ -0,0 +1,56 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Account
+          class PrepaidTransactionsController < Spree::Api::V2::ResourceController
+            before_action :require_spree_current_user
+
+            # See PrepaidTransaction::CUSTOMER_FACING_TYPES for which types these are and why.
+            # top_up/admin_credit are the credit-increasing rows; authorize is the negative (hold)
+            # row at spend time, already stored with a negative amount (see
+            # StoreCreditEventDecorator#signed_amount) so no sign flip is needed here. void is the
+            # reversal of an authorize that never captured (order failed/abandoned) -- its amount
+            # is positive (money back), pairing with the authorize row it reverses so a "Purchase"
+            # doesn't look permanent when it wasn't.
+            DISPLAYED_TRANSACTION_TYPES = SpreeCmCommissioner::PrepaidTransaction::CUSTOMER_FACING_TYPES
+
+            def index
+              if params[:currency].present?
+                currency = params[:currency].to_s.upcase
+                unless Spree::Store.default.supported_currency_codes.include?(currency)
+                  return render_error_payload("unsupported currency: #{currency}")
+                end
+              end
+
+              super
+            end
+
+            def collection
+              @collection ||= SpreeCmCommissioner::PrepaidTransaction
+                              .where(store_credit_id: prepaid_credit_ids, transaction_type: DISPLAYED_TRANSACTION_TYPES)
+                              .includes(order: { payments: :payment_method })
+                              .order(created_at: :desc)
+            end
+
+            private
+
+            # Mirrors PrepaidBalancesController#presented_collection -- an optional ?currency=
+            # narrows to one wallet, omitted returns transactions across every currency the user
+            # holds. Previously pinned to current_currency (session/store default), which had no
+            # way to request a non-default wallet's history, so a KHR top-up never showed up here
+            # even though its cm_prepaid_transactions row was written correctly.
+            def prepaid_credit_ids
+              currency = params[:currency].presence&.upcase
+              spree_current_user.store_credits.platform_prepaid(currency).pluck(:id)
+            end
+
+            def collection_serializer
+              Spree::V2::Storefront::PrepaidTransactionSerializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/cart_payment_fees_controller.rb

@@ -0,0 +1,48 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        # GET /api/v2/storefront/cart_payment_fees?payment_method_ids[]=1&payment_method_ids[]=2
+        #
+        # Payment fee each requested payment method would add to the current cart. Order-scoped
+        # and uncached on purpose: the answer depends on line items and applied store credit, both
+        # of which change on the payment screen. The client skips methods whose catalog entry says
+        # `fee_configured: false`, so carts with no fees configured never hit this.
+        class CartPaymentFeesController < Spree::Api::V2::ResourceController
+          include OrderConcern
+
+          before_action :ensure_order
+
+          # override
+          def index
+            render_serialized_payload do
+              collection_serializer.new(collection).serializable_hash
+            end
+          end
+
+          # override
+          def collection
+            @collection ||= requested_payment_methods.map do |payment_method|
+              SpreeCmCommissioner::PaymentFees::Preview.call(order: spree_current_order, payment_method: payment_method)
+                                                       .value[:payment_fee_preview]
+            end
+          end
+
+          # override
+          def collection_serializer
+            SpreeCmCommissioner::V2::Storefront::PaymentFeePreviewSerializer
+          end
+
+          private
+
+          # Ids the order can't actually pay with are dropped rather than rejected, so a stale client
+          # list (e.g. a method disabled since the catalog was cached) still gets the rest.
+          def requested_payment_methods
+            ids = Array(params[:payment_method_ids]).map(&:to_s)
+            spree_current_order.available_payment_methods.select { |pm| ids.include?(pm.id.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/draft_orders_controller.rb

@@ -9,6 +9,10 @@ module Spree
 
           before_action -> { ensure_anonymous_booking_allowed!(draft_order_products) }, only: :create
 
+          # A top-up credits a wallet, which must belong to a real user -- unlike #create,
+          # this action has no guest-checkout path.
+          before_action :require_spree_current_user, only: [:topup]
+
           # Creates a generic draft order from a locally-assembled cart in a single request.
           # Endpoint: POST /api/v2/storefront/draft_orders
           # Params:
@@ -36,6 +40,39 @@ module Spree
             end
           end
 
+          # Builds a prepaid top-up order from just an amount and a payment method -- the client
+          # never fetches/knows the prepaid_top_up product or variant.
+          # Endpoint: POST /api/v2/storefront/draft_orders/topup
+          # Params:
+          # - amount: the custom top-up amount (required)
+          # - payment_method_id: id of the payment method to attach (required)
+          # - currency: the wallet currency the client's own currency picker selected (optional --
+          #   TopupDraftOrders::Create falls back to store.default_currency when nil). Deliberately
+          #   NOT current_currency: that helper resolves general storefront browsing currency
+          #   (session -> ?currency= -> store default) -- a stale session[:currency] would
+          #   silently override what the client explicitly picked here, leading to the amount
+          #   being validated against the wrong currency's min/max (e.g. a KHR amount checked
+          #   against the USD cap).
+          def topup
+            result = SpreeCmCommissioner::TopupDraftOrders::Create.call(
+              amount: params[:amount],
+              payment_method_id: params[:payment_method_id],
+              user: spree_current_user,
+              store: current_store,
+              currency: params[:currency].presence&.upcase,
+              options: {
+                device_id: device_id,
+                last_ip_address: request.remote_ip
+              }
+            )
+
+            if result.success?
+              render_serialized_payload(201) { serialize_resource(serializable_order(result.value[:order])) }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
           private
 
           # Re-fetch the created order with everything the enriched payload touches eager-loaded, so

data/app/controllers/spree/api/v2/storefront/prepaid_config_controller.rb

@@ -0,0 +1,22 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        # Endpoint: GET /api/v2/storefront/prepaid_config
+        # Public (no sign-in required): a guest should be able to discover currencies/limits
+        # before a top-up is submitted.
+        class PrepaidConfigController < Spree::Api::V2::ResourceController
+          def show
+            render_serialized_payload { serialize_resource(SpreeCmCommissioner::PrepaidConfig.resolve) }
+          end
+
+          private
+
+          def resource_serializer
+            Spree::V2::Storefront::PrepaidConfigSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/reschedule_requests_controller.rb

@@ -0,0 +1,156 @@
+# Customer-initiated reschedule lifecycle, scoped to the signed-in customer's
+# own bookings. Every action delegates to the same RescheduleRequests::*
+# services the vendor console drives.
+#
+# Actions:
+# - index/show - the customer's own requests only, scoped by `load_request!`
+# - preview - quote only, nothing persisted, terms not required yet
+# - create - persists and auto-advances per policy
+# - pay - online balance-due payment
+# - cancel - withdraws a request already in flight
+#
+
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class RescheduleRequestsController < ::Spree::Api::V2::ResourceController
+          before_action :require_spree_current_user
+
+          def index
+            render_serialized_payload { serialize_collection(paginated_collection) }
+          end
+
+          def show
+            render_serialized_payload { serialize_resource(load_request!) }
+          end
+
+          def preview
+            result = run_initiate(preview: true)
+            return render_error_payload(result.error) if result.failure?
+
+            render_serialized_payload { { data: preview_payload(result.value) } }
+          end
+
+          def create
+            return render_error_payload(I18n.t('reschedule_requests.initiate.terms_not_accepted')) unless terms_accepted?
+
+            result = run_initiate(
+              preview: false,
+              terms_accepted_at: Time.current,
+              reason: reschedule_params[:reason]
+            )
+            return render_error_payload(result.error) if result.failure?
+
+            render_serialized_payload(201) { serialize_resource(result.value[:reschedule_request]) }
+          end
+
+          def cancel
+            result = SpreeCmCommissioner::RescheduleRequests::Cancel.call(
+              reschedule_request: load_request!,
+              cancelled_by: spree_current_user,
+              reason: params[:reason]
+            )
+            return render_error_payload(result.error) if result.failure?
+
+            render_serialized_payload { serialize_resource(result.value[:reschedule_request]) }
+          end
+
+          def pay
+            result = SpreeCmCommissioner::RescheduleRequests::CollectPayment.call(
+              reschedule_request: load_request!,
+              payment_params: payment_params,
+              acting_user: spree_current_user
+            )
+            return render_error_payload(result.error) if result.failure?
+
+            render_serialized_payload do
+              Spree::V2::Storefront::PaymentSerializer.new(result.value[:payment], params: serializer_params).serializable_hash
+            end
+          end
+
+          private
+
+          def terms_accepted?
+            ActiveModel::Type::Boolean.new.cast(reschedule_params[:terms_accepted])
+          end
+
+          def run_initiate(preview:, terms_accepted_at: nil, reason: nil)
+            SpreeCmCommissioner::RescheduleRequests::Initiate.call(
+              order_id: reschedule_params[:order_number],
+              line_item_ids: reschedule_params[:line_item_ids],
+              new_from_date: reschedule_params[:new_from_date],
+              new_to_date: reschedule_params[:new_to_date],
+              targets: reschedule_params[:targets],
+              initiated_by: spree_current_user,
+              initiated_as: 'user',
+              options: {
+                preview: preview,
+                terms_accepted_at: terms_accepted_at,
+                reason: reason,
+                request_ip: request.remote_ip
+              }.compact
+            )
+          end
+
+          def load_request!
+            SpreeCmCommissioner::RescheduleRequest
+              .for_user(spree_current_user.id)
+              .find_by!(number: params[:id])
+          end
+
+          def collection
+            SpreeCmCommissioner::RescheduleRequest
+              .for_user(spree_current_user.id)
+              .includes(:order, :previous_request_snapshots, :new_request_snapshots)
+              .order(id: :desc)
+          end
+
+          def default_resource_includes
+            %w[before_snapshots after_snapshots]
+          end
+
+          def resource_serializer
+            SpreeCmCommissioner::V2::Storefront::RescheduleRequestSerializer
+          end
+
+          def collection_serializer
+            SpreeCmCommissioner::V2::Storefront::RescheduleRequestSerializer
+          end
+
+          def preview_payload(value)
+            request = value[:reschedule_request]
+            {
+              fee_amount: request.fee_amount,
+              amount_due_total: request.amount_due_total,
+              credit_amount_total: request.credit_amount_total,
+              currency: request.currency,
+              payment_required: request.payment_required?,
+              requires_vendor_approval: value[:requires_vendor_approval],
+              fee_breakdown: value[:fee_breakdown]
+            }
+          end
+
+          def reschedule_params
+            params.require(:reschedule_request).permit(
+              :order_number, :new_from_date, :new_to_date, :reason, :terms_accepted,
+              line_item_ids: [],
+              targets: [
+                :line_item_id, :new_from_date, :new_to_date, :trip_id,
+                :boarding_trip_stop_id, :drop_off_trip_stop_id, :variant_id,
+                { guest_ids: [], block_ids: [] }
+              ]
+            )
+          end
+
+          def payment_params
+            params.require(:payment).permit(
+              :payment_method_id, :payment_option, :gateway_payment_profile_id,
+              :gateway_customer_profile_id, :last_digits, :month, :year, :name
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/seat_layouts_controller.rb

@@ -10,6 +10,8 @@ module Spree
         class SeatLayoutsController < Spree::Api::V2::ResourceController
           # GET /api/v2/storefront/seat_layouts/:id
           # - include_details=true|false (optional, default: true)
+          #
+          # Always returns `product_ids` (see SeatLayout#product_ids).
           def show
             render_serialized_payload { serialize_resource(resource) }
           end
@@ -70,7 +72,7 @@ module Spree
 
           # override
           def serializer_params
-            super.merge(include_details: include_details?)
+            super.merge(include_details: include_details?, include_product_ids: action_name == 'show')
           end
 
           # default return true

data/app/controllers/spree/api/v2/storefront/transit/item_availabilities_controller.rb

@@ -0,0 +1,66 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Transit
+          class ItemAvailabilitiesController < ::Spree::Api::V2::ResourceController
+            include SpreeCmCommissioner::Integrations::InventorySyncCachable
+
+            def create
+              sync_result = sync_item_availability!
+
+              unless sync_result.success?
+                error_message = sync_result.to_h.dig(:error, :message) || 'Sync failed'
+                return render_error_payload(error_message, 422)
+              end
+
+              item_availability = SpreeCmCommissioner::ItemAvailabilitySync.new(
+                id: trip.id,
+                last_sync_at: sync_result.last_synced_at
+              )
+              render_serialized_payload { serialize_resource(item_availability) }
+            rescue ActiveRecord::RecordNotFound => e
+              render_error_payload(e.message, 404)
+            end
+
+            private
+
+            def trip
+              @trip ||= SpreeCmCommissioner::Trip.find(params[:trip_id])
+            end
+
+            def integration
+              @integration ||= trip.vendor&.integration
+            end
+
+            def sync_item_availability!
+              # Return success result if vendor has no integration
+              return SpreeCmCommissioner::Integrations::Base::SyncResult.new if integration.nil?
+
+              # Check cache first for successful results only
+              cached_result = Rails.cache.read(sync_cache_key)
+              return cached_result if cached_result
+
+              # Perform sync
+              result = integration.sync_item_availability!(trip_id: trip.id, on_date: params[:on_date])
+
+              # Only cache successful results to avoid sticky failures
+              Rails.cache.write(sync_cache_key, result, expires_in: sync_cache_ttl) if result.success?
+
+              result
+            end
+
+            def sync_cache_key
+              # Include trip.updated_at to auto-bust cache when trip is updated by background syncs
+              "item_availability_syncs:#{trip.id}:#{params[:on_date]}:#{trip.updated_at.to_i}"
+            end
+
+            def resource_serializer
+              SpreeCmCommissioner::V2::Storefront::ItemAvailabilitySyncSerializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/account/prepaid_balances_controller.rb

@@ -0,0 +1,51 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        module Account
+          # Endpoint: GET /api/v2/tenant/account/prepaid_balances
+          # Single endpoint for both "my one balance" and "all my balances" -- an optional
+          # ?currency= filters down to one (still an array, just 0-or-1 items; hard-rejected if
+          # outside the tenant's supported_currencies_list, via BaseController#
+          # resolve_requested_currency), omitted returns every currency this tenant has issued the
+          # user (ignoring supported_currencies_list -- a balance in a since-unsupported currency
+          # stays visible/spendable). Replaces the old separate GET account/prepaid (show) +
+          # GET account/prepaid_balances (index) pair -- see Storefront::Account::
+          # PrepaidController's own comment for why one endpoint with a fixed array shape beats
+          # two endpoints whose response type differs by param.
+          class PrepaidBalancesController < BaseController
+            before_action :require_spree_current_user
+
+            def index
+              currency = nil
+              if params[:currency].present?
+                currency, error = resolve_requested_currency
+                return render_error_payload(error) if error
+              end
+
+              render_serialized_payload { collection_serializer.new(presented_collection(currency)).serializable_hash }
+            end
+
+            private
+
+            # Tenant-issued prepaid credit only (Spree::StoreCredit#tenant_prepaid) -- unlike the
+            # storefront version, this is never platform-issued credit: a tenant's own wallet
+            # screen shows only what that tenant itself issued this user. Preferred currency
+            # sorted first -- see Storefront::Account::PrepaidBalancesController's own comment.
+            def presented_collection(currency)
+              preferred_currency = @tenant.preferred_currency_or_default
+              credits = spree_current_user.store_credits.tenant_prepaid(@tenant.id, currency).to_a
+              credits.sort_by! { |credit| credit.currency == preferred_currency ? 0 : 1 }
+
+              credits.map { |credit| SpreeCmCommissioner::PrepaidBalancePresenter.new(credit, preferred_currency) }
+            end
+
+            def collection_serializer
+              Spree::V2::Tenant::PrepaidBalanceSerializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/account/prepaid_transactions_controller.rb

@@ -0,0 +1,53 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        module Account
+          # Endpoint: GET /api/v2/tenant/account/prepaid_transactions
+          # Mirrors Spree::Api::V2::Storefront::Account::PrepaidTransactionsController, scoped to
+          # this tenant's own issued credit only (Spree::StoreCredit#tenant_prepaid) -- same
+          # scoping split as Tenant::Account::PrepaidController vs its storefront counterpart.
+          class PrepaidTransactionsController < BaseController
+            before_action :require_spree_current_user
+
+            # See PrepaidTransaction::CUSTOMER_FACING_TYPES for which types these are and why.
+            DISPLAYED_TRANSACTION_TYPES = SpreeCmCommissioner::PrepaidTransaction::CUSTOMER_FACING_TYPES
+
+            # Overridden (rather than left to ResourceController#index) so an out-of-list
+            # ?currency= is a hard rejection here too, same as Tenant::Account::PrepaidController
+            # #show -- without this check, collection's `prepaid_credit&.id` would just silently
+            # render an empty list for a bad currency instead of telling the client why.
+            def index
+              _currency, error = resolve_requested_currency
+              return render_error_payload(error) if error
+
+              super
+            end
+
+            def collection
+              @collection ||= SpreeCmCommissioner::PrepaidTransaction
+                              .where(store_credit_id: prepaid_credit&.id, transaction_type: DISPLAYED_TRANSACTION_TYPES)
+                              .includes(order: { payments: :payment_method })
+                              .order(created_at: :desc)
+            end
+
+            private
+
+            # Same currency resolution as Tenant::Account::PrepaidController#show -- the currency
+            # this tenant's wallet screen is currently viewing, not every currency at once (that's
+            # what prepaid_balances is for). #index already rejected a bad currency above, so
+            # resolve_requested_currency's error here is always nil by the time collection runs.
+            def prepaid_credit
+              currency, = resolve_requested_currency
+              @prepaid_credit ||= spree_current_user.store_credits.tenant_prepaid(@tenant.id, currency).take
+            end
+
+            def collection_serializer
+              Spree::V2::Tenant::PrepaidTransactionSerializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/tenant/base_controller.rb

@@ -20,6 +20,26 @@ module Spree
             @current_vendor ||= @tenant.active_vendor
           end
 
+          # current_currency/supported_currency?/supported_currencies are tenant-aware via
+          # Spree::Core::ControllerHelpers::CurrencyDecorator (keys off @tenant, set above) --
+          # see that file for the tenant-vs-store resolution logic.
+
+          # Resolves the wallet currency for a tenant-scoped prepaid request: an explicit
+          # ?currency= param must be inside this tenant's own supported_currencies_list -- a hard
+          # rejection, not a silent fallback, per the design doc (a currency outside the
+          # tenant's configured set would otherwise make the restriction cosmetic). Omitted,
+          # falls back to Tenant#preferred_currency_or_default. Returns [currency, error_message]
+          # -- error_message is nil on success.
+          def resolve_requested_currency
+            requested = params[:currency].presence
+            return [@tenant.preferred_currency_or_default, nil] if requested.blank?
+
+            currency = requested.to_s.upcase
+            return [nil, "unsupported currency: #{currency}"] unless @tenant.supports_currency?(currency)
+
+            [currency, nil]
+          end
+
           def render_serialized_payload(status = 200)
             render json: yield, status: status, content_type: content_type
           end