spree_cm_commissioner 2.8.3 → 2.8.4.pre.pre2

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

@@ -0,0 +1,43 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class VotingContestantsController < BaseController
+          before_action :load_voting_session, only: %i[index]
+
+          # override
+          def collection
+            @collection ||= @voting_session
+                            .voting_contestants
+                            .includes(:voting_session, :show_contestant,
+                                      :show_contestant_images, :show_contestant_videos,
+                                      :advanced_to, :advanced_from
+                            )
+                            .order(:id)
+          end
+
+          # override
+          def collection_serializer
+            Spree::V2::Tenant::VotingContestantSerializer
+          end
+
+          private
+
+          # override
+          def model_class
+            SpreeCmCommissioner::VotingSession
+          end
+
+          # override
+          def scope
+            current_vendor.voting_sessions.includes(:episode)
+          end
+
+          def load_voting_session
+            @voting_session = scope.find(params[:voting_session_id])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class VotingCreditTransactionsController < BaseController
+          before_action :require_spree_current_user
+
+          def index
+            render_serialized_payload do
+              serialize_collection(collection)
+            end
+          end
+
+          private
+
+          def collection
+            @collection ||= scope.page(params[:page])
+                                 .per(params[:per_page])
+          end
+
+          def scope
+            scope = spree_current_user.voting_credit_transactions
+                                      .includes(:vote_credit, :originator)
+                                      .order(created_at: :desc)
+
+            scope = scope.by_action(params[:actions].split(',')) if params[:actions].present?
+            scope
+          end
+
+          def model_class
+            SpreeCmCommissioner::VotingCreditTransaction
+          end
+
+          def collection_serializer
+            Spree::V2::Tenant::VotingCreditTransactionSerializer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class VotingCreditsController < BaseController
+          before_action :require_spree_current_user
+
+          def index
+            render_serialized_payload do
+              serialize_resource(voting_credit)
+            end
+          end
+
+          private
+
+          def voting_credit
+            spree_current_user.voting_credits.active.eligible(load_voting_session).first
+          end
+
+          def load_voting_session
+            @voting_session ||= SpreeCmCommissioner::VotingSession.find(params[:voting_session_id])
+          end
+
+          def resource_serializer
+            Spree::V2::Tenant::VotingCreditSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree_cm_commissioner/admin/orders_controller_decorator.rb

@@ -40,9 +40,13 @@ module SpreeCmCommissioner
 
       # override
       def cancel
-        internal_note = params.dig(:order, :internal_note)
-        @order.canceled_by(try_spree_current_user, cancellation_reason: internal_note)
-        flash[:success] = Spree.t(:order_canceled)
+        if @order.guests_in_transfer?
+          flash[:error] = Spree.t('admin.orders.cannot_cancel_guest_transfer')
+        else
+          internal_note = params.dig(:order, :internal_note)
+          @order.canceled_by(try_spree_current_user, cancellation_reason: internal_note)
+          flash[:success] = Spree.t(:order_canceled)
+        end
         redirect_back fallback_location: spree.edit_admin_order_url(@order)
       end
 

data/app/controllers/spree_cm_commissioner/admin/products_controller_decorator.rb

@@ -6,6 +6,7 @@ module SpreeCmCommissioner
         base.around_action :set_writing_role, only: %i[index]
         base.after_action :set_tenant_after_update, only: %i[update]
         base.before_action :merge_industry_taxons_into_taxons, only: [:update]
+        base.before_action :normalize_sti_product_params, only: %i[create update]
       end
 
       # Override
@@ -51,6 +52,24 @@ module SpreeCmCommissioner
 
       protected
 
+      # Some admin forms submit STI records under their class key while
+      # Spree update reads :product. Merge both into :product so all edited
+      # fields are persisted for STI product subclasses.
+      def normalize_sti_product_params
+        return unless @product
+
+        sti_key = @product.class.model_name.param_key.to_sym
+        sti_params = params[sti_key]
+        return unless sti_params.is_a?(::ActionController::Parameters)
+
+        base_params = params[:product]
+        base_hash = base_params.is_a?(::ActionController::Parameters) ? base_params.to_unsafe_h : {}
+        sti_hash = sti_params.to_unsafe_h
+        merged_params = ::ActionController::Parameters.new(base_hash.merge(sti_hash))
+
+        params[:product] = merged_params
+      end
+
       def merge_industry_taxons_into_taxons
         return if params[:product].blank?
 

data/app/finders/spree_cm_commissioner/events/find_matches.rb

@@ -7,6 +7,7 @@ module SpreeCmCommissioner
       def execute
         scope.joins(:integration_mappings).where(
           kind: :event,
+          preview: false,
           integration_mappings: { status: :active }
         ).distinct
       end

data/app/helpers/spree_cm_commissioner/admin/guest_helper.rb

@@ -61,6 +61,16 @@ module SpreeCmCommissioner
           'badge-info'
         end
       end
+
+      def guest_state_badge(guest)
+        badge_class = case guest.state
+                      when 'active' then 'badge-success'
+                      when 'locked' then 'badge-warning'
+                      when 'transferred' then 'badge-secondary'
+                      else 'badge-info'
+                      end
+        content_tag(:span, guest.state.humanize, class: "badge #{badge_class}")
+      end
     end
   end
 end

data/app/helpers/spree_cm_commissioner/admin/homepage_segment_helper.rb

@@ -15,6 +15,8 @@ module SpreeCmCommissioner
           'badge badge-success text-uppercase'
         when :football
           'badge badge-dark text-uppercase'
+        when :show
+          'badge badge-danger text-uppercase'
         else
           'badge'
         end

data/app/helpers/spree_cm_commissioner/admin/ticket_transfers_helper.rb

@@ -0,0 +1,32 @@
+module SpreeCmCommissioner
+  module Admin
+    module TicketTransfersHelper
+      def ticket_transfer_state_badge(state)
+        badge_class = case state
+                      when 'pending' then 'badge-warning'
+                      when 'accepted' then 'badge-info'
+                      when 'completed' then 'badge-success'
+                      when 'rejected' then 'badge-danger'
+                      when 'expired' then 'badge-danger' # rubocop:disable Lint/DuplicateBranch
+                      when 'cancelled' then 'badge-secondary'
+                      else 'badge-secondary' # rubocop:disable Lint/DuplicateBranch
+                      end
+
+        content_tag(:span, state.humanize, class: "badge #{badge_class}")
+      end
+
+      def ticket_transfer_settlement_status_badge(ticket_transfer)
+        badge_class = case ticket_transfer.settlement_status
+                      when 'pending' then 'badge-warning'
+                      when 'ready' then 'badge-info'
+                      when 'disputed' then 'badge-danger'
+                      when 'resolved' then 'badge-primary'
+                      when 'completed' then 'badge-success'
+                      else 'badge-secondary'
+                      end
+
+        content_tag(:span, ticket_transfer.settlement_status.humanize, class: "badge #{badge_class}")
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/pin_code_sender.rb

@@ -6,7 +6,7 @@ module  SpreeCmCommissioner
       context.fail!(message: I18n.t('pincode_sender.pincode.blank')) if context.pin_code.nil?
 
       if context.pin_code.phone_number?
-        send_sms
+        send_phone_otp
       else
         send_email
       end
@@ -16,18 +16,73 @@ module  SpreeCmCommissioner
 
     private
 
-    def send_sms
+    # Channel selection for phone-number OTPs lives here so the routing is
+    # easy to find and reason about. Telegram Gateway is primary; SMS is the fallback.
+    def send_phone_otp
+      if telegram_gateway_available?
+        send_via_telegram_gateway
+      else
+        send_via_sms
+      end
+    end
+
+    def telegram_gateway_available?
+      return false unless telegram_gateway_enabled?
+      return false if telegram_gateway_api_key.blank?
+
+      ability = telegram_gateway_adapter.check_send_ability(context.pin_code.contact)
+      context.telegram_gateway_request_id = ability.request_id if ability.ok?
+      ability.ok?
+    rescue TelegramGatewayAdapter::Error, Faraday::Error
+      false
+    end
+
+    def send_via_telegram_gateway
       from_number = sms_from_number
       return if from_number.blank?
 
-      options = {
+      # Save the chosen channel + the Telegram request_id synchronously so
+      # (a) the API response already reflects the channel for the mobile UI,
+      # (b) verification can reach Telegram even if the user submits the OTP
+      #     before the async send job has run. For Telegram-delivered codes
+      #     the `code` column stores Telegram's request_id (Telegram generates
+      #     and holds the actual OTP).
+      context.pin_code.update!(
+        delivery_channel: :telegram_gateway,
+        code: context.telegram_gateway_request_id
+      )
+
+      SpreeCmCommissioner::TelegramGateway::PinCodeSenderJob.perform_later(
+        pin_code_id: context.pin_code.id,
+        from: from_number,
+        request_id: context.telegram_gateway_request_id,
+        tenant_id: context.pin_code&.application&.tenant_id
+      )
+    end
+
+    def send_via_sms
+      from_number = sms_from_number
+      return if from_number.blank?
+
+      SpreeCmCommissioner::SmsPinCodeJob.perform_later(
+        pin_code_id: context.pin_code.id,
         from: from_number,
         to: context.pin_code.contact,
         body: I18n.t('pincode_sender.sms.body', code: context.pin_code.code, readable_type: context.pin_code.readable_type),
         tenant_id: context.pin_code&.application&.tenant_id
-      }
+      )
+    end
+
+    def telegram_gateway_enabled?
+      ENV['TELEGRAM_GATEWAY_ENABLED'] == 'yes'
+    end
 
-      SpreeCmCommissioner::SmsPinCodeJob.perform_later(options)
+    def telegram_gateway_api_key
+      @telegram_gateway_api_key ||= ENV.fetch('TELEGRAM_GATEWAY_API_KEY', nil)
+    end
+
+    def telegram_gateway_adapter
+      @telegram_gateway_adapter ||= TelegramGatewayAdapter::Client.new
     end
 
     def sms_from_number
@@ -38,6 +93,8 @@ module  SpreeCmCommissioner
     end
 
     def send_email
+      context.pin_code.update!(delivery_channel: :email)
+
       SpreeCmCommissioner::PinCodeMailer.send_pin_code(
         context.pin_code.id,
         context.pin_code.readable_type,

data/app/interactors/spree_cm_commissioner/waiting_guests_caller.rb

@@ -3,6 +3,9 @@ require 'google/cloud/firestore'
 # TODO: alert when available_slots is negative.
 module SpreeCmCommissioner
   class WaitingGuestsCaller < BaseInteractor
+    MIN_WAIT_TO_ENTER_SECONDS = 120 # 2 min floor — Waiting Room step (full journey, more uncertainty)
+    MIN_QUEUE_TO_ENTER_SECONDS = 60 # 1 min floor — Queue step (position assigned, one caller cycle minimum)
+
     def call
       available_slots = fetch_available_slots
       return unless available_slots.positive?
@@ -10,7 +13,12 @@ module SpreeCmCommissioner
       long_waiting_guests = fetch_long_waiting_guests(available_slots)
       calling_all(long_waiting_guests)
 
-      mark_as(full: long_waiting_guests.size >= available_slots, available_slots: available_slots - long_waiting_guests.size)
+      mark_as(
+        full: long_waiting_guests.size >= available_slots,
+        available_slots: available_slots - long_waiting_guests.size,
+        avg_wait_to_enter_seconds: compute_avg_wait_to_enter_seconds(long_waiting_guests),
+        avg_queue_to_enter_seconds: compute_avg_queue_to_enter_seconds(long_waiting_guests)
+      )
     end
 
     def fetch_available_slots
@@ -19,18 +27,47 @@ module SpreeCmCommissioner
       max_sessions - active_sessions
     end
 
-    # This query required index. create them in Firebase beforehand.
-    # Client side must create waiting_guests document with :queued_at & :allow_to_enter_room_at to null to allow fillter & order.
+    # This query requires an index; create it in Firebase beforehand.
+    # Client must create waiting_guests documents with :queued_at and :allow_to_enter_room_at set to nil to allow filter + order queries.
+    #
+    # Yesterday's guests are always older than today's, so fill from yesterday first, then use any
+    # leftover slots for today. This way no one queued before the midnight rollover gets skipped.
+    #   e.g. 5 slots, 2 waiting in yesterday -> take both, then take 3 from today.
     def fetch_long_waiting_guests(available_slots)
-      firestore.col('waiting_guests')
-               .doc(current_date)
-               .col('records')
+      previous_guests = eligible_guests_in(previous_records_path, available_slots)
+
+      # Pre-flip window: the lobby pointer still points at yesterday, so both paths resolve to the
+      # same partition — return now to avoid querying (and double-counting) it twice.
+      return previous_guests if records_path == previous_records_path
+
+      remaining_slots = available_slots - previous_guests.size
+      return previous_guests if remaining_slots <= 0
+
+      previous_guests + eligible_guests_in(records_path, remaining_slots)
+    end
+
+    def eligible_guests_in(records_path, limit)
+      firestore.col(records_path)
                .where('allow_to_enter_room_at', '==', nil)
                .order('queued_at')
-               .limit(available_slots)
+               .limit(limit)
                .get.to_a
     end
 
+    # Published path is authoritative; fall back to the server's own date if not yet published.
+    def records_path
+      lobby_data&.dig(:waiting_guests_records_path).presence || default_records_path(current_date)
+    end
+
+    # Drain target is derived from the server date, never the (possibly stale) lobby pointer.
+    def previous_records_path
+      default_records_path(previous_date)
+    end
+
+    def default_records_path(date)
+      "waiting_guests/#{date}/records"
+    end
+
     # For alert waiting guests to enter room, we just update :allow_to_enter_room_at.
     # App will listen to firebase & start refresh session token to enter room.
     def calling_all(waiting_guests)
@@ -45,9 +82,48 @@ module SpreeCmCommissioner
       Time.zone.now.strftime('%Y-%m-%d')
     end
 
-    # When open app, app request to check whether room is full or not via Firebase instead of server to minimize server requests.
-    def mark_as(full:, available_slots:)
-      firestore.col('waiting_rooms').doc('lobby').set({ full: full, available_slots: available_slots })
+    def previous_date
+      1.day.ago.strftime('%Y-%m-%d')
+    end
+
+    # merge: true so we preserve the published `waiting_guests_records_path` on the lobby doc.
+    def mark_as(full:, available_slots:, avg_wait_to_enter_seconds: nil, avg_queue_to_enter_seconds: nil)
+      data = { full: full, available_slots: available_slots }
+      data[:avg_wait_to_enter_seconds] = avg_wait_to_enter_seconds if avg_wait_to_enter_seconds
+      data[:avg_queue_to_enter_seconds] = avg_queue_to_enter_seconds if avg_queue_to_enter_seconds
+      lobby_document.set(data, merge: true)
+    end
+
+    # Average total wait (queued_at → allow_to_enter_room_at) for just-called guests.
+    # Used for the Waiting Room step ETA: how long until I get in from when I joined.
+    def compute_avg_wait_to_enter_seconds(guests)
+      return nil if guests.empty?
+
+      now = Time.zone.now
+      total = guests.sum { |doc| (now - doc.data[:queued_at].to_time).to_f }
+      [(total / guests.size).round, MIN_WAIT_TO_ENTER_SECONDS].max
+    end
+
+    # Average queue wait (position_set_at → allow_to_enter_room_at) for just-called guests.
+    # Used for the Queue step ETA: how long after getting a position until I actually enter.
+    # Returns nil when none of the called guests had position_set_at (first run, or no prior stamp).
+    def compute_avg_queue_to_enter_seconds(guests)
+      return nil if guests.empty?
+
+      now = Time.zone.now
+      positioned = guests.select { |doc| doc.data[:position_set_at] }
+      return nil if positioned.empty?
+
+      total = positioned.sum { |doc| (now - doc.data[:position_set_at].to_time).to_f }
+      [(total / positioned.size).round, MIN_QUEUE_TO_ENTER_SECONDS].max
+    end
+
+    def lobby_data
+      @lobby_data ||= lobby_document.get.data
+    end
+
+    def lobby_document
+      @lobby_document ||= firestore.col('waiting_rooms').doc('lobby')
     end
 
     def fetch_max_sessions

data/app/jobs/spree_cm_commissioner/expire_ticket_transfer_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  class ExpireTicketTransferJob < ApplicationJob
+    def perform(transfer_id)
+      ticket_transfer = SpreeCmCommissioner::TicketTransfer.find_by(id: transfer_id)
+      return unless ticket_transfer
+
+      SpreeCmCommissioner::TicketTransfers::Expire.call(ticket_transfer: ticket_transfer)
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/show_contestants/import_job.rb

@@ -0,0 +1,9 @@
+module SpreeCmCommissioner
+  module ShowContestants
+    class ImportJob < ApplicationJob
+      def perform(import_id)
+        SpreeCmCommissioner::Imports::Contestants::Create.new(import_id: import_id).call
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/telegram_gateway/pin_code_sender_job.rb

@@ -0,0 +1,18 @@
+module SpreeCmCommissioner
+  module TelegramGateway
+    # options = { pin_code_id:, from:, request_id:, tenant_id: }
+    class PinCodeSenderJob < SpreeCmCommissioner::SmsJob
+      def perform(options = {})
+        pin_code = SpreeCmCommissioner::PinCode.find_by(id: options[:pin_code_id])
+        return if pin_code.nil?
+
+        SpreeCmCommissioner::TelegramGateway::PinCodeSender.call(
+          pin_code: pin_code,
+          from: options[:from],
+          request_id: options[:request_id],
+          tenant_id: options[:tenant_id]
+        )
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/vendor_route_metrics/decrease_trip_count_job.rb

@@ -0,0 +1,17 @@
+module SpreeCmCommissioner
+  module VendorRouteMetrics
+    class DecreaseTripCountJob < ApplicationUniqueJob
+      def perform(options = {})
+        vendor_route_metric = SpreeCmCommissioner::VendorRouteMetric.find_by(
+          vendor_id: options[:vendor_id],
+          origin_place_id: options[:origin_place_id],
+          destination_place_id: options[:destination_place_id],
+          route_type: options[:route_type]
+        )
+        return if vendor_route_metric.nil?
+
+        SpreeCmCommissioner::VendorRouteMetrics::DecreaseTripCount.call(vendor_route_metric: vendor_route_metric)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/vendor_route_metrics/increase_trip_count_job.rb

@@ -0,0 +1,14 @@
+module SpreeCmCommissioner
+  module VendorRouteMetrics
+    class IncreaseTripCountJob < ApplicationUniqueJob
+      def perform(options = {})
+        SpreeCmCommissioner::VendorRouteMetrics::IncreaseTripCount.call(
+          vendor_id: options[:vendor_id],
+          origin_place_id: options[:origin_place_id],
+          destination_place_id: options[:destination_place_id],
+          route_type: options[:route_type]
+        )
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/vote_fraud_event_job.rb

@@ -0,0 +1,9 @@
+module SpreeCmCommissioner
+  class VoteFraudEventJob < ApplicationJob
+    queue_as :default
+
+    def perform(options = {})
+      SpreeCmCommissioner::VoteFraudEvent.create!(options)
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/voting_credit_allocation_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  class VotingCreditAllocationJob < ApplicationUniqueJob
+    def perform(options = {})
+      order = Spree::Order.find_by(id: options[:order_id])
+      return if order.nil?
+
+      SpreeCmCommissioner::VotingCredits::Allocate.new(order).call
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/voting_credit_de_allocation_job.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  class VotingCreditDeAllocationJob < ApplicationUniqueJob
+    def perform(options = {})
+      order = Spree::Order.find_by(id: options[:order_id])
+      return if order.nil?
+
+      SpreeCmCommissioner::VotingCredits::DeAllocate.new(order).call
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/waiting_room/publish_lobby_path_job.rb

@@ -0,0 +1,17 @@
+# waiting_room_lobby_path_publisher:
+#   cron: "0 0 * * * Asia/Phnom_Penh" # Once per day at local midnight (date rollover)
+#   class: "SpreeCmCommissioner::WaitingRoom::PublishLobbyPathJob"
+module SpreeCmCommissioner
+  module WaitingRoom
+    class PublishLobbyPathJob < ApplicationJob
+      queue_as :waiting_room
+
+      def perform
+        return if ENV['WAITING_ROOM_DISABLED'] == 'yes'
+
+        # call! so a publish failure raises (Sidekiq retries/alerts) instead of being silently swallowed.
+        SpreeCmCommissioner::WaitingRoom::PublishLobbyPath.call!
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/waiting_room/stamp_queue_positions_job.rb

@@ -0,0 +1,84 @@
+require 'google/cloud/firestore'
+
+module SpreeCmCommissioner
+  module WaitingRoom
+    class StampQueuePositionsJob < ApplicationJob
+      queue_as :waiting_room
+
+      STAMP_LIMIT = (ENV['WAITING_ROOM_POSITION_STAMP_LIMIT'] || 1000).to_i
+
+      def perform
+        paths = stamp_paths
+        avg_queue_to_enter = lobby_data[:avg_queue_to_enter_seconds].to_i
+        total = paths.sum { |p| waiting_count(p) }
+        return if total.zero?
+
+        stamped_at = Time.zone.now
+        global = 0
+
+        paths.each do |path|
+          remaining = STAMP_LIMIT - global
+          break if remaining <= 0
+
+          docs = waiting_query(path).order('queued_at').limit(remaining).get.to_a
+          docs.each_slice(500) do |slice|
+            firestore.batch do |b|
+              slice.each do |doc|
+                global += 1
+                data = {
+                  position: global,
+                  queue_total: total,
+                  estimated_wait_seconds: avg_queue_to_enter,
+                  status_updated_at: stamped_at
+                }
+                data[:position_set_at] = stamped_at unless doc.data[:position_set_at]
+                b.update(doc.ref, data)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def stamp_paths
+        [previous_records_path, records_path]
+      end
+
+      def records_path
+        default_records_path(Time.zone.now.strftime('%Y-%m-%d'))
+      end
+
+      def previous_records_path
+        default_records_path(1.day.ago.strftime('%Y-%m-%d'))
+      end
+
+      def default_records_path(date)
+        "waiting_guests/#{date}/records"
+      end
+
+      def waiting_count(path)
+        waiting_query(path).aggregate_query.add_count.get.first.get.to_i
+      end
+
+      def waiting_query(path)
+        firestore.col(path).where('allow_to_enter_room_at', '==', nil)
+      end
+
+      def lobby_data
+        @lobby_data ||= firestore.col('waiting_rooms').doc('lobby').get.data || {}
+      end
+
+      def firestore
+        @firestore ||= Google::Cloud::Firestore.new(
+          project_id: service_account[:project_id],
+          credentials: service_account
+        )
+      end
+
+      def service_account
+        @service_account ||= Rails.application.credentials.cloud_firestore_service_account
+      end
+    end
+  end
+end