spree_cm_commissioner 2.5.0.pre.pre13 → 2.5.0.pre.pre14

data/app/services/spree_cm_commissioner/calculate_distance.rb

@@ -0,0 +1,279 @@
+# Computes trip distance details for intercity taxi trips.
+#
+# == Purpose
+# Calculate total distance, detour distances, and chargeable "extra km"
+# when pickups/dropoffs deviate from the standard intercity route.
+#
+# == INPUT (keyword args)
+#   trip_id:              [Integer]  REQUIRED - SpreeCmCommissioner::Trip id
+#   pickups_attributes:   [Array]    Optional waypoints BEFORE the route (e.g. hotel pickup)
+#   dropoffs_attributes:  [Array]    Required waypoints AT/NEAR destination (e.g. specific address)
+#   pickup_oob_confirmed: [Boolean]  If true, charge extra km for pickup detours beyond boundary
+#   dropoff_oob_confirmed:[Boolean]  If true, charge extra km for dropoff detours beyond boundary
+#
+#   Waypoint format (understood by GoogleRoutesDistanceCalculator):
+#     { lat: Float, lng: Float }
+#
+# == OUTPUT (Result object)
+#   result.success?  => true/false
+#   result.failure?  => true/false
+#   result.value     => SpreeCmCommissioner::Distance (on success)
+#   result.error     => String error message (on failure)
+#
+# == Distance Value Object Fields
+#   distance_km:            Total route distance (with all waypoints)
+#   ordered_points:         Array of { lat:, lng: } in travel order
+#   estimated_time_minutes: ETA from Google (nil for simple routes)
+#   base_km:                Distance without any waypoints (origin → destination)
+#   detour_pickup_km:       Distance when only pickups are added (nil if not calculated)
+#   detour_dropoff_km:      Distance when only dropoffs are added (nil if not calculated)
+#   extra_pickup_km:        Chargeable km beyond pickup boundary (0.0 if within free zone)
+#   extra_dropoff_km:       Chargeable km beyond dropoff boundary (0.0 if within free zone)
+#
+# == Example Usage
+#   result = SpreeCmCommissioner::CalculateDistance.call(
+#     trip_id: 123,
+#     pickups_attributes: [{ lat: 11.55, lng: 104.91 }],
+#     dropoffs_attributes: [{ lat: 13.36, lng: 103.86 }],
+#     pickup_oob_confirmed: true,
+#     dropoff_oob_confirmed: true
+#   )
+#   if result.success?
+#     distance = result.value
+#     puts "Total: #{distance.distance_km} km, Extra pickup charge: #{distance.extra_pickup_km} km"
+#   else
+#     puts "Error: #{result.error}"
+#   end
+#
+module SpreeCmCommissioner
+  class CalculateDistance
+    prepend ::Spree::ServiceModule::Base
+
+    def call(
+      pickups_attributes: [],
+      dropoffs_attributes: [],
+      pickup_oob_confirmed: false,
+      dropoff_oob_confirmed: false,
+      trip_id: nil
+    )
+      return failure(nil, 'trip_id is required') if trip_id.blank?
+
+      @trip_id = trip_id
+      @pickup_oob_confirmed = pickup_oob_confirmed
+      @dropoff_oob_confirmed = dropoff_oob_confirmed
+
+      @pickups_points = Array(pickups_attributes).compact
+      @dropoffs_points = Array(dropoffs_attributes).compact
+
+      @final_destination = @dropoffs_points.last
+
+      return failure(nil, 'Trip origin location is not configured') if origin_point.blank?
+      return failure(nil, 'Trip destination location is not configured') if destination_point.blank?
+      return failure(nil, 'At least one dropoff is required') if @dropoffs_points.empty?
+
+      # Step 1: Calculate base route (no waypoints) - this is the reference for detour calculations
+      base_km = calculate_base_route_km
+      return failure(nil, 'Unable to calculate base route') if base_km.nil?
+
+      # Step 2: Calculate full route with all waypoints (optimized order)
+      details_ctx = fetch_full_route_details
+      return failure(nil, details_ctx.error || 'Unable to calculate route') unless details_ctx.success?
+
+      # Step 3: Calculate detour distances and derive extra chargeable km
+      detour_distances = calculate_detour_distances
+      build_result(details_ctx, base_km, detour_distances)
+    rescue StandardError => e
+      failure(nil, e.message)
+    end
+
+    private
+
+    # ===========================================
+    # DISTANCE CALCULATIONS
+    # ===========================================
+
+    # Base route: origin → destination (no waypoints)
+    # This is the "ideal" shortest route the operator priced for.
+    def calculate_base_route_km
+      compute_km(origin: origin_point, destination: destination_point)
+    end
+
+    # Full route: origin → pickups → dropoffs → final_destination
+    # Google optimizes waypoint order for shortest path.
+    def fetch_full_route_details
+      SpreeCmCommissioner::GoogleRoutesDistanceCalculator.call(
+        origin: origin_point,
+        destination: @final_destination,
+        pickups: @pickups_points,
+        dropoffs: @dropoffs_points,
+        optimize: true
+      )
+    end
+
+    # Detour distances are calculated separately for pickups and dropoffs.
+    # These help us determine how much extra distance each type of waypoint adds.
+    def calculate_detour_distances
+      {
+        pickup: calculate_pickup_detour_km,
+        dropoff: calculate_dropoff_detour_km
+      }
+    end
+
+    # Pickup detour: origin → pickups → destination (no dropoffs)
+    # Only calculated if pickups exist AND user confirmed OOB charge.
+    def calculate_pickup_detour_km
+      return nil unless @pickups_points.any? && @pickup_oob_confirmed
+
+      compute_km(
+        origin: origin_point,
+        destination: destination_point,
+        pickups: @pickups_points,
+        optimize: false # Keep pickup order as specified
+      )
+    end
+
+    # Dropoff detour: origin → dropoffs → final_destination (no pickups)
+    # Only calculated if dropoffs exist AND user confirmed OOB charge.
+    def calculate_dropoff_detour_km
+      return nil unless @dropoffs_points.any? && @dropoff_oob_confirmed
+
+      compute_km(
+        origin: origin_point,
+        destination: @final_destination,
+        dropoffs: @dropoffs_points,
+        optimize: false # Keep dropoff order as specified
+      )
+    end
+
+    # ===========================================
+    # RESULT BUILDERS
+    # ===========================================
+
+    # Full result with waypoints - includes detour and extra km calculations
+    def build_result(details_ctx, base_km, detour_distances)
+      # Calculate how many extra km each detour adds compared to base route
+      # Example: If base = 50km and pickup_detour = 58km, then increment = 8km
+      pickup_increment_km = detour_distances[:pickup].present? ? detour_distances[:pickup] - base_km : 0.0
+      dropoff_increment_km = detour_distances[:dropoff].present? ? detour_distances[:dropoff] - base_km : 0.0
+
+      # Calculate chargeable extra km (beyond free boundary allowance)
+      extra_pickup_km = compute_extra_km(pickup_increment_km, pickup_boundary_km, @pickup_oob_confirmed)
+      extra_dropoff_km = compute_extra_km(dropoff_increment_km, dropoff_boundary_km, @dropoff_oob_confirmed)
+
+      distance = SpreeCmCommissioner::Distance.new(
+        distance_km: details_ctx.distance_km,
+        ordered_points: details_ctx.ordered_points,
+        estimated_time_minutes: details_ctx.estimated_time_minutes,
+        base_km: base_km,
+        detour_pickup_km: detour_distances[:pickup],
+        detour_dropoff_km: detour_distances[:dropoff],
+        extra_pickup_km: extra_pickup_km,
+        extra_dropoff_km: extra_dropoff_km
+      )
+
+      success(distance)
+    end
+
+    # ===========================================
+    # EXTRA KM CALCULATION
+    #
+    # "Extra km" = detour km that exceeds a free boundary allowance.
+    # - Operators allow some detour for free (e.g., 5km for pickups)
+    # - Only km beyond that boundary is charged
+    #
+    # Example:
+    #   base_km = 50, detour_km = 58 → increment = 8km
+    #   boundary = 5km → extra = 8 - 5 = 3km chargeable
+    # ===========================================
+
+    # Calculate chargeable extra km beyond the free boundary
+    #
+    # @param increment_km [Float] How much longer the detour is vs base
+    # @param boundary_km [Float] Free allowance (no charge below this)
+    # @param confirmed [Boolean] Whether OOB charge was confirmed
+    # @return [Float] Chargeable km (0.0 if within free zone or not confirmed)
+    def compute_extra_km(increment_km, boundary_km, confirmed)
+      return 0.0 unless confirmed && increment_km
+
+      extra = increment_km - boundary_km.to_f
+      extra.positive? ? extra.round(2) : 0.0
+    end
+
+    # ===========================================
+    # GOOGLE ROUTES INTEGRATION
+    # ===========================================
+
+    # Wrapper to call GoogleRoutesDistanceCalculator and extract distance_km
+    # Returns nil if the calculation fails.
+    def compute_km(origin:, destination:, pickups: nil, dropoffs: nil, optimize: nil)
+      context = SpreeCmCommissioner::GoogleRoutesDistanceCalculator.call(
+        origin: origin,
+        destination: destination,
+        pickups: pickups,
+        dropoffs: dropoffs,
+        optimize: optimize
+      )
+      return nil unless context.success?
+
+      context.distance_km
+    end
+
+    # ===========================================
+    # BOUNDARIES (Free Detour Allowance)
+    #
+    # TODO: Allow operators to configure these per trip/vendor (in the future)
+    # ===========================================
+
+    # Free pickup detour allowance (km)
+    def pickup_boundary_km
+      5.0
+    end
+
+    # Free dropoff detour allowance (km)
+    def dropoff_boundary_km
+      3.0
+    end
+
+    # ===========================================
+    # TRIP HELPERS - Resolve origin/destination from Trip
+    # ===========================================
+
+    def trip
+      @trip ||= SpreeCmCommissioner::Trip.find(@trip_id)
+    end
+
+    # Get origin point from trip's vendor location configuration
+    # Returns { lat:, lng: } hash or nil
+    def origin_point
+      @origin_point ||=
+        if trip.blank?
+          nil
+        else
+          location = trip.vendor.locations.find_by(place: trip.origin_place)
+          to_point(location&.branches&.first&.place)
+        end
+    end
+
+    # Get destination point from trip's vendor location configuration
+    # Returns { lat:, lng: } hash or nil
+    def destination_point
+      @destination_point ||=
+        if trip.blank?
+          nil
+        else
+          location = trip.vendor.locations.find_by(place: trip.destination_place)
+          to_point(location&.branches&.first&.place)
+        end
+    end
+
+    # Convert a Place model to { lat:, lng: } hash
+    def to_point(place)
+      return nil if place.blank?
+
+      {
+        lat: place.lat.to_f,
+        lng: place.lon.to_f
+      }
+    end
+  end
+end

data/app/services/spree_cm_commissioner/cart/recalculate_decorator.rb

@@ -7,7 +7,34 @@ module SpreeCmCommissioner
         # order should be reload before recaculate to avoid wrong caculation.
         order.reload
 
-        super
+        # SPREE: Original Spree::Cart::Recalculate code starts here
+        order_updater = ::Spree::OrderUpdater.new(order)
+
+        order.payments.store_credits.checkout.destroy_all
+        order_updater.update
+
+        shipment = options[:shipment]
+        if shipment.present?
+          # ADMIN END SHIPMENT RATE FIX
+          # refresh shipments to ensure correct shipment amount is calculated when using price sack calculator
+          # for calculating shipment rates.
+          # Currently shipment rate is calculated on previous order total instead of current order total when updating a shipment from admin end.
+          order.refresh_shipment_rates(::Spree::ShippingMethod::DISPLAY_ON_BACK_END)
+          shipment.update_amounts
+        else
+          order.ensure_updated_shipments
+        end
+        # SPREE: Original Spree::Cart::Recalculate code ends here
+
+        # CUSTOM: Apply pricing models (intercity taxi, line item pricing) to the line item
+        SpreeCmCommissioner::LineItems::ApplyPricingModels.call(order: order, line_item: line_item)
+
+        # SPREE: Original Spree::Cart::Recalculate code continues here
+        ::Spree::PromotionHandler::Cart.new(order, line_item).activate
+        ::Spree::Adjustable::AdjustmentsUpdater.update(line_item)
+        ::Spree::TaxRate.adjust(order, [line_item.reload]) if line_item_created
+        order_updater.update
+        success(line_item)
       end
     end
   end

data/app/services/spree_cm_commissioner/guests/claim_invite_guest_service.rb

@@ -0,0 +1,65 @@
+module SpreeCmCommissioner
+  module Guests
+    class ClaimInviteGuestService
+      prepend ::Spree::ServiceModule::Base
+
+      def call(guest:, id_card_params:, line_item:, invite_guest:)
+        ApplicationRecord.transaction do
+          process_id_cards(guest, id_card_params)
+          claim_invite_if_needed(line_item, invite_guest)
+          send_claim_alert(guest, invite_guest.order)
+
+          success(guest: guest.reload)
+        end
+      rescue StandardError => e
+        failure(guest, e.message)
+      end
+
+      private
+
+      # ID Card Processing
+      def process_id_cards(guest, id_card_params)
+        return unless id_card_images_present?(id_card_params)
+
+        id_card = guest.id_card || guest.build_id_card(card_type: id_card_params[:card_type])
+        build_id_card_images(id_card, id_card_params)
+        id_card.save!
+      end
+
+      def build_id_card_images(id_card, id_card_params)
+        id_card.build_front_image(attachment: id_card_params.delete(:front_image)) if id_card_params[:front_image]
+        id_card.build_back_image(attachment: id_card_params.delete(:back_image)) if id_card_params[:back_image]
+      end
+
+      def id_card_images_present?(id_card_params)
+        id_card_params[:front_image].present? || id_card_params[:back_image].present?
+      end
+
+      # Invite Claim Management
+      def claim_invite_if_needed(line_item, invite_guest)
+        return unless line_item.guests.count >= invite_guest.quantity
+
+        invite_guest.update(claimed_status: :claimed)
+      end
+
+      # Telegram Alert
+      def send_claim_alert(guest, order)
+        vendor = guest.event&.vendor
+        return unless vendor&.preferred_telegram_chat_id
+
+        factory = SpreeCmCommissioner::InviteGuestClaimedTelegramMessageFactory.new(
+          title: '📣 --- [NEW GUEST CLAIMED INVITATION] ---',
+          order: order,
+          guest: guest,
+          vendor: vendor
+        )
+
+        SpreeCmCommissioner::TelegramNotificationSenderJob.perform_later(
+          chat_id: vendor.preferred_telegram_chat_id,
+          message: factory.message,
+          parse_mode: factory.parse_mode
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/intercity_taxi_order/calculate_distance.rb

@@ -0,0 +1,224 @@
+module SpreeCmCommissioner
+  module IntercityTaxiOrder
+    # Computes trip distance details for intercity taxi orders
+    class CalculateDistance
+      prepend ::Spree::ServiceModule::Base
+
+      def call(
+        pickups_attributes: [],
+        dropoffs_attributes: [],
+        pickup_oob_confirmed: false,
+        dropoff_oob_confirmed: false,
+        trip_id: nil
+      )
+        return failure(nil, 'trip_id is required') if trip_id.blank?
+
+        initialize_context(pickup_oob_confirmed, dropoff_oob_confirmed, trip_id)
+        setup_waypoints(pickups_attributes, dropoffs_attributes)
+
+        return failure(nil, 'Trip origin location is not configured') if origin.blank?
+        return failure(nil, 'Trip destination location is not configured') if configured_destination.blank?
+
+        base_km = calculate_base_route
+        return failure(nil, 'Unable to calculate base route') if base_km.nil?
+        return build_simple_result(base_km) unless waypoints?
+
+        details_ctx = fetch_full_route_details
+        return failure(nil, details_ctx.message || 'Unable to calculate') unless details_ctx.success?
+
+        detour_distances = calculate_detour_distances
+        build_result(details_ctx, base_km, detour_distances)
+      rescue StandardError => e
+        failure(nil, e.message)
+      end
+
+      private
+
+      # -------------------------
+      # Setup
+      # -------------------------
+
+      def initialize_context(pickup_oob_confirmed, dropoff_oob_confirmed, trip_id)
+        @trip_id = trip_id
+        @pickup_oob_confirmed = pickup_oob_confirmed
+        @dropoff_oob_confirmed = dropoff_oob_confirmed
+      end
+
+      def setup_waypoints(pickups_attributes, dropoffs_attributes)
+        @pickups_points = Array(pickups_attributes).compact
+        @dropoffs_points = Array(dropoffs_attributes).compact
+        @final_destination = @dropoffs_points.last || configured_destination
+
+        @has_pickups = @pickups_points.any?
+        @has_dropoffs = @dropoffs_points.any?
+      end
+
+      def waypoints?
+        @has_pickups || @has_dropoffs
+      end
+
+      # -------------------------
+      # Distance calculations
+      # -------------------------
+
+      def calculate_base_route
+        compute_km(origin: origin, destination: configured_destination)
+      end
+
+      def fetch_full_route_details
+        fetch_details(origin, @final_destination, @pickups_points, @dropoffs_points)
+      end
+
+      def calculate_detour_distances
+        {
+          pickup: calculate_pickup_detour,
+          dropoff: calculate_dropoff_detour
+        }
+      end
+
+      def calculate_pickup_detour
+        return nil unless @has_pickups && @pickup_oob_confirmed
+
+        compute_km(
+          origin: origin,
+          destination: configured_destination,
+          pickups: @pickups_points,
+          optimize: false
+        )
+      end
+
+      def calculate_dropoff_detour
+        return nil unless @has_dropoffs && @dropoff_oob_confirmed
+
+        compute_km(
+          origin: origin,
+          destination: @final_destination,
+          dropoffs: @dropoffs_points,
+          optimize: false
+        )
+      end
+
+      # -------------------------
+      # Result builders
+      # -------------------------
+
+      def build_simple_result(base_km)
+        result = SpreeCmCommissioner::IntercityTaxi::DistanceCalculationResult.new(
+          distance_km: base_km,
+          ordered_points: [origin, configured_destination],
+          estimated_time_minutes: nil,
+          base_km: base_km,
+          detour_pickup_km: nil,
+          detour_dropoff_km: nil,
+          extra_pickup_km: 0.0,
+          extra_dropoff_km: 0.0
+        )
+        success(result)
+      end
+
+      def build_result(details_ctx, base_km, detour_distances)
+        # Incremental km = detour - base
+        pickup_increment_km = detour_distances[:pickup]&.-(base_km)
+        dropoff_increment_km = detour_distances[:dropoff]&.-(base_km)
+
+        extra_pickup_km = compute_extra_km(pickup_increment_km, pickup_boundary_km, @pickup_oob_confirmed)
+        extra_dropoff_km = compute_extra_km(dropoff_increment_km, dropoff_boundary_km, @dropoff_oob_confirmed)
+
+        result = SpreeCmCommissioner::IntercityTaxi::DistanceCalculationResult.new(
+          distance_km: details_ctx.distance_km,
+          ordered_points: details_ctx.ordered_points,
+          estimated_time_minutes: details_ctx.estimated_time_minutes,
+          base_km: base_km,
+          detour_pickup_km: detour_distances[:pickup],
+          detour_dropoff_km: detour_distances[:dropoff],
+          extra_pickup_km: extra_pickup_km,
+          extra_dropoff_km: extra_dropoff_km
+        )
+
+        success(result)
+      end
+
+      # -------------------------
+      # Extra km calculation
+      # -------------------------
+
+      # increment_km = detour_km - base_km
+      def compute_extra_km(increment_km, boundary_km, confirmed)
+        return 0.0 unless confirmed && increment_km
+
+        extra = increment_km - boundary_km.to_f
+        extra.positive? ? extra.round(2) : 0.0
+      end
+
+      # -------------------------
+      # Google Routes integration
+      # -------------------------
+
+      def compute_km(origin:, destination:, pickups: nil, dropoffs: nil, optimize: nil)
+        ctx = SpreeCmCommissioner::GoogleRoutesDistanceCalculator.call(
+          origin: origin,
+          destination: destination,
+          pickups: pickups,
+          dropoffs: dropoffs,
+          optimize: optimize
+        )
+        return nil unless ctx.success?
+
+        ctx.distance_km
+      end
+
+      def fetch_details(origin, final_destination, pickups_points, dropoffs_points)
+        SpreeCmCommissioner::GoogleRoutesDistanceCalculator.call(
+          origin: origin,
+          destination: final_destination,
+          pickups: pickups_points,
+          dropoffs: dropoffs_points,
+          optimize: true
+        )
+      end
+
+      # -------------------------
+      # Boundaries
+      # -------------------------
+
+      def pickup_boundary_km
+        5.0
+      end
+
+      def dropoff_boundary_km
+        3.0
+      end
+
+      # -------------------------
+      # Trip helpers
+      # -------------------------
+
+      def trip
+        @trip ||= SpreeCmCommissioner::Trip.find(@trip_id)
+      end
+
+      def origin
+        return if trip.blank?
+
+        location = trip.vendor.locations.find_by(place: trip.origin_place)
+        to_point(location&.branches&.first)
+      end
+
+      def configured_destination
+        return if trip.blank?
+
+        location = trip.vendor.locations.find_by(place: trip.destination_place)
+        to_point(location&.branches&.first)
+      end
+
+      def to_point(location)
+        return if location.blank? || location.place.blank?
+
+        {
+          lat: location.place.lat.to_f,
+          lng: location.place.lon.to_f
+        }
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/intercity_taxi_order/update.rb

@@ -3,6 +3,8 @@ module SpreeCmCommissioner
     class Update
       prepend ::Spree::ServiceModule::Base
 
+      include ::Spree::LineItems::Helper
+
       def call(
         order:,
         remark: nil,
@@ -26,18 +28,43 @@ module SpreeCmCommissioner
           )
         end
 
+        # Verify signature and extract data for distance
         if distance_attributes.present?
-          line_item.distance = SpreeCmCommissioner::IntercityTaxi::Distance.new(
-            distance_attributes
-          )
+          verified_data = verify_and_extract_distance(distance_attributes)
+          return failure(nil, verified_data[:error]) unless verified_data[:success]
+
+          line_item.distance = SpreeCmCommissioner::Distance.new(verified_data[:value])
         end
 
         line_item.update!(remark: remark)
+        recalculate_service.call(order: order, line_item: line_item)
 
         success(order.reload)
       rescue StandardError => e
         failure(nil, e.message)
       end
+
+      private
+
+      # Verifies signed distance data and extracts clean data (without signature).
+      # Signature is only used for verification, not stored.
+      def verify_and_extract_distance(attributes)
+        # Convert to Hash with string keys (works for both Hash and ActionController::Parameters)
+        # Controller already called .permit(), so .to_h is safe here
+        # HashWithIndifferentAccess.to_json works correctly, so we can use it directly
+        attributes = attributes.to_h.stringify_keys
+
+        return { success: false, error: 'Distance signature is required' } if attributes['signature'].blank?
+
+        # Verify signature before using for price calculations
+        verified = SpreeCmCommissioner::Distance.from_signed_hash(attributes)
+        return { success: false, error: 'Invalid distance signature or tampered data' } unless verified
+
+        # Extract clean data without signature and signed_at
+        clean_data = verified.to_h
+
+        { success: true, value: clean_data }
+      end
     end
   end
 end

data/app/services/spree_cm_commissioner/line_items/apply_pricing_models.rb

@@ -0,0 +1,27 @@
+module SpreeCmCommissioner
+  module LineItems
+    class ApplyPricingModels
+      prepend ::Spree::ServiceModule::Base
+
+      def call(order:, line_item:)
+        return success(nil) if line_item.blank?
+
+        return success(line_item) unless order&.persisted?
+        return success(line_item) if line_item.variant.blank?
+
+        active_pricing_models = line_item.variant.pricing_models.active
+        return success(line_item) unless active_pricing_models.exists?
+
+        line_item.adjustments.pricing_action.delete_all
+
+        active_pricing_models.each do |pricing_model|
+          SpreeCmCommissioner::PricingModels::Apply.new(
+            line_item: line_item,
+            pricing_model: pricing_model
+          ).call
+        end
+        success(line_item)
+      end
+    end
+  end
+end