spree_cm_commissioner 2.3.2 → 2.4.0

data/app/serializers/spree/v2/tenant/trip_serializer.rb

@@ -0,0 +1,8 @@
+module Spree
+  module V2
+    module Tenant
+      class TripSerializer < SpreeCmCommissioner::V2::Storefront::TripSerializer
+      end
+    end
+  end
+end

data/app/serializers/spree_cm_commissioner/v2/storefront/intercity_taxi_line_item_serializer.rb

@@ -2,29 +2,28 @@ module SpreeCmCommissioner
   module V2
     module Storefront
       class IntercityTaxiLineItemSerializer < BaseSerializer
-        attributes :pickup_place_name,
-                   :drop_off_place_name,
-                   :pickup_lat,
-                   :pickup_lng,
-                   :drop_off_lat,
-                   :drop_off_lng,
-                   :passenger_count,
-                   :distance_km,
-                   :ordered_points,
-                   :base_km,
-                   :detour_pickup_km,
-                   :detour_dropoff_km,
-                   :extra_pickup_km,
-                   :extra_dropoff_km,
-                   :extra_pickup_charge_usd,
-                   :extra_dropoff_charge_usd,
-                   :estimated_time_minutes,
+        # Nested-only API shape
+        attributes :pickup_map_place,
+                   :dropoff_map_place,
+                   :distance,
                    :from_date,
                    :to_date,
-                   :direction,
+                   :remark,
                    :trip_id
 
         cache_options store: nil
+
+        def pickup_map_place
+          object.pickup_map_place&.to_h
+        end
+
+        def dropoff_map_place
+          object.dropoff_map_place&.to_h
+        end
+
+        def distance
+          object.distance&.to_h
+        end
       end
     end
   end

data/app/serializers/spree_cm_commissioner/v2/storefront/route_serializer.rb

@@ -0,0 +1,12 @@
+module SpreeCmCommissioner
+  module V2
+    module Storefront
+      class RouteSerializer < BaseSerializer
+        attributes :route_name
+
+        has_one :origin_place, serializer: ::Spree::V2::Storefront::PlaceSerializer
+        has_one :destination_place, serializer: ::Spree::V2::Storefront::PlaceSerializer
+      end
+    end
+  end
+end

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

@@ -1,35 +1,19 @@
 module SpreeCmCommissioner
   module IntercityTaxiOrder
     class Create
-      attr_reader :trip_id, :from_date, :to_date, :user_id, :quantity
+      prepend ::Spree::ServiceModule::Base
 
-      def self.call(trip_id:, from_date:, to_date:, user_id: nil, quantity: 1)
-        new(
-          trip_id: trip_id,
-          from_date: from_date,
-          to_date: to_date,
-          user_id: user_id,
-          quantity: quantity
-        ).call
-      end
-
-      def initialize(trip_id:, from_date:, to_date:, user_id:, quantity:)
-        @trip_id = trip_id
-        @from_date = from_date
-        @to_date = to_date
-        @user_id = user_id
-        @quantity = quantity.to_i <= 0 ? 1 : quantity.to_i
-      end
+      def call(trip_id:, from_date:, to_date:, user: nil, quantity: 1)
+        validate!(trip_id: trip_id, from_date: from_date, to_date: to_date, quantity: quantity)
 
-      def call
-        validate!
+        quantity = quantity.to_i
 
-        ActiveRecord::Base.transaction do
+        order = ActiveRecord::Base.transaction do
           trip = SpreeCmCommissioner::Trip.find(trip_id)
           variant = trip.product.variants.first
           raise ArgumentError, 'No variant found for trip' if variant.blank?
 
-          order = Spree::Order.new(state: 'cart', use_billing: true, user_id: user_id)
+          order = Spree::Order.new(state: 'cart', use_billing: true, user: user)
 
           line_item = order.line_items.new(
             variant_id: variant.id,
@@ -42,26 +26,39 @@ module SpreeCmCommissioner
           )
 
           build_guests_for!(line_item, quantity)
+          assign_saved_guests_to_line_item(line_item)
 
           order.save!
           order.update_with_updater!
 
           order
         end
+
+        success(order)
+      rescue StandardError => e
+        failure(nil, e.message)
       end
 
       private
 
-      def validate!
+      def validate!(trip_id:, from_date:, to_date:, quantity:)
         raise ArgumentError, 'trip_id is required' if trip_id.blank?
         raise ArgumentError, 'from_date is required' if from_date.blank?
         raise ArgumentError, 'to_date is required' if to_date.blank?
         raise ArgumentError, 'to_date must be after from_date' if from_date.present? && to_date.present? && to_date < from_date
+        raise ArgumentError, 'quantity must be 1' if quantity.to_i != 1
       end
 
       def build_guests_for!(line_item, qty)
         Array.new(qty) { line_item.guests.new }
       end
+
+      def assign_saved_guests_to_line_item(line_item)
+        line_item.guests.each do |guest|
+          saved_guest = SpreeCmCommissioner::SavedGuest.new
+          guest.saved_guest = saved_guest
+        end
+      end
     end
   end
 end

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

@@ -1,78 +1,42 @@
 module SpreeCmCommissioner
   module IntercityTaxiOrder
     class Update
-      attr_reader :order_number, :params
-
-      def self.call(order_number:, params:)
-        new(order_number: order_number, params: params).call
-      end
-
-      def initialize(order_number:, params:)
-        @order_number = order_number
-        @params = ensure_parameters(params)
-      end
-
-      def call
-        order = Spree::Order.find_by!(number: order_number)
-        order.update!(order_params)
-
-        create_billing_address_if_missing(order)
-
-        order
-      end
-
-      private
-
-      def ensure_parameters(params)
-        return params if params.is_a?(::ActionController::Parameters)
-
-        ::ActionController::Parameters.new(params)
-      end
-
-      def create_billing_address_if_missing(order)
-        return if order.bill_address.present?
-
-        SpreeCmCommissioner::BillingAddressCreator.call(order: order)
-      end
-
-      def order_params
-        params.require(:order).permit(
-          :intel_phone_number,
-          :email,
-          line_items_attributes: [
-            :id,
-            :pickup_place_name,
-            :drop_off_place_name,
-            :from_date,
-            :pickup_lat,
-            :pickup_lng,
-            :pickup_oob_confirmed,
-            :drop_off_lat,
-            :drop_off_lng,
-            :drop_off_oob_confirmed,
-            :distance_km,
-            :ordered_points,
-            :base_km,
-            :detour_pickup_km,
-            :detour_dropoff_km,
-            :extra_pickup_km,
-            :extra_dropoff_km,
-            :extra_pickup_charge_usd,
-            :extra_dropoff_charge_usd,
-            :estimated_time_minutes,
-            :remark,
-            :passenger_count,
-            { guests_attributes: %i[
-              id
-              first_name
-              last_name
-              gender
-              nationality_id
-              age
-            ]
-            }
-          ]
-        )
+      prepend ::Spree::ServiceModule::Base
+
+      def call(
+        order:,
+        remark: nil,
+        pickup_map_place_attributes: nil,
+        dropoff_map_place_attributes: nil,
+        distance_attributes: nil
+      )
+        line_item = order.line_items.first
+
+        raise ArgumentError, 'Order has no line items' if line_item.blank?
+
+        if pickup_map_place_attributes.present?
+          line_item.pickup_map_place = SpreeCmCommissioner::IntercityTaxi::MapPlace.new(
+            pickup_map_place_attributes
+          )
+        end
+
+        if dropoff_map_place_attributes.present?
+          line_item.dropoff_map_place = SpreeCmCommissioner::IntercityTaxi::MapPlace.new(
+            dropoff_map_place_attributes
+          )
+        end
+
+        if distance_attributes.present?
+          line_item.distance = SpreeCmCommissioner::IntercityTaxi::Distance.new(
+            distance_attributes
+          )
+        end
+
+        line_item.update!(remark: remark)
+
+        success(order.reload)
+      rescue StandardError => e
+        failure(nil, e.message)
       end
     end
   end

data/app/services/spree_cm_commissioner/pricing_models/apply.rb

@@ -0,0 +1,51 @@
+module SpreeCmCommissioner
+  module PricingModels
+    class Apply
+      def initialize(line_item_id:, pricing_model_id:)
+        @line_item_id = line_item_id
+        @pricing_model_id = pricing_model_id
+      end
+
+      def call
+        pricing_model.pricing_rule_groups.each do |group|
+          apply_group(group, line_item)
+        end
+      end
+
+      private
+
+      attr_reader :line_item_id, :pricing_model_id
+
+      def line_item
+        @line_item ||= Spree::LineItem.find(line_item_id)
+      end
+
+      def pricing_model
+        @pricing_model ||= SpreeCmCommissioner::PricingModel.find(pricing_model_id)
+      end
+
+      def apply_group(group, line_item)
+        eligible_rules = group.pricing_rules.select { |r| r.eligible?(line_item) }
+
+        return if eligible_rules.empty?
+
+        if group_eligible?(group, eligible_rules)
+          group.pricing_action&.perform(line_item)
+        else
+          Rails.logger.info("Group #{group.id} not eligible for line_item #{line_item.id}")
+        end
+      end
+
+      def group_eligible?(group, eligible_rules)
+        case group.match_type
+        when 'all'
+          eligible_rules.size == group.pricing_rules.size
+        when 'any'
+          eligible_rules.any?
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/pricing_rules/build_params.rb

@@ -0,0 +1,53 @@
+module SpreeCmCommissioner
+  module PricingRules
+    module BuildParams
+      module_function
+
+      def permitted_group_params(params)
+        group_params = params[:spree_cm_commissioner_pricing_rule_group] || params
+
+        {
+          name: group_params[:name],
+          status: group_params[:status],
+          template_key: group_params[:template_key],
+          match_type: group_params[:match_type],
+          pricing_rules_attributes: build_rules_attributes(params[:pricing_rules]),
+          pricing_action_attributes: build_action_attributes(params[:pricing_action])
+        }
+      end
+
+      def build_rules_attributes(rules_array)
+        return [] unless rules_array
+
+        rules_array.map do |r|
+          {
+            id: r[:id],
+            type: r[:type],
+            private_metadata: r[:private_metadata],
+            _destroy: r[:_destroy]
+          }
+        end
+      end
+
+      def build_action_attributes(action_data)
+        return nil unless action_data&.dig(:calculator)
+
+        calc_data = action_data[:calculator]
+        calculator = calc_data[:type].safe_constantize&.new
+        set_preferences(calculator, calc_data[:preferences]) if calculator
+
+        { id: action_data[:id], calculator: calculator }
+      end
+
+      def set_preferences(calculator, preferences)
+        return unless preferences && calculator
+
+        prefs = preferences.respond_to?(:to_unsafe_h) ? preferences.to_unsafe_h : preferences
+        prefs.each do |key, value|
+          setter = "preferred_#{key}="
+          calculator.public_send(setter, value) if calculator.respond_to?(setter)
+        end
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/pricing_rules/build_template.rb

@@ -0,0 +1,27 @@
+module SpreeCmCommissioner
+  module PricingRules
+    class BuildTemplate
+      def self.call(pricing_model:, template_key:)
+        template = PRICING_RULE_GROUP_TEMPLATES[template_key.to_sym]
+        return unless template
+
+        group = pricing_model.pricing_rule_groups.build
+
+        template[:rules]&.each do |rule_data|
+          group.pricing_rules.where(type: rule_data[:type]).build(
+            type: rule_data[:type],
+            private_metadata: rule_data[:private_metadata] || {}
+          )
+        end
+
+        if template[:action]
+          calculator = template[:action][:calculator_type].constantize.new
+          BuildParams.set_preferences(calculator, template[:action][:preferences])
+          group.build_pricing_action(calculator: calculator)
+        end
+
+        group
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/pricing_rules/create.rb

@@ -0,0 +1,10 @@
+module SpreeCmCommissioner
+  module PricingRules
+    class Create
+      def self.call(pricing_model:, params:)
+        attrs = BuildParams.permitted_group_params(params)
+        pricing_model.pricing_rule_groups.create(attrs)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  module PricingRules
+    class Update
+      def self.call(pricing_rule_group:, params:)
+        attrs = BuildParams.permitted_group_params(params)
+        pricing_rule_group.update(attrs)
+        pricing_rule_group
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/vendor_places/base.rb

@@ -0,0 +1,24 @@
+module SpreeCmCommissioner
+  module VendorPlaces
+    class Base
+      prepend ::Spree::ServiceModule::Base
+
+      ALLOWED_PLACE_TYPES = %w[venue stop branch location].freeze
+
+      private
+
+      def validate_place_type!(place_type)
+        return I18n.t('controller.vendor_places.place_type_required', default: 'Place type is required') if place_type.nil?
+
+        unless ALLOWED_PLACE_TYPES.include?(place_type.to_s)
+          return I18n.t(
+            'controller.vendor_places.invalid_place_type',
+            default: "Place type must be one of: #{ALLOWED_PLACE_TYPES.join(', ')}"
+          )
+        end
+
+        nil
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/vendor_places/bulk_create.rb

@@ -0,0 +1,70 @@
+# Bulk creates vendor places of any valid type (e.g., :stop, :branch, :location) with validation and transaction support.
+#
+# Validates place_ids count and creates vendor places atomically.
+# Rolls back all changes if any creation fails.
+#
+# Usage:
+#   result = SpreeCmCommissioner::VendorPlaces::BulkCreate.call(
+#     vendor: current_vendor,
+#     place_ids: [1, 2, 3],
+#     place_type: :location, # or :stop, :branch, etc.
+#     description: "Sample description",
+#     max_count: 10,
+#     location: parent_location # required for :stop and :branch
+#   )
+#
+#   if result.success?
+#     created_vendor_places = result.value
+#   else
+#     error_message = result.error
+
+module SpreeCmCommissioner
+  module VendorPlaces
+    class BulkCreate < Base
+      def call(vendor:, place_ids:, place_type:, description: nil, max_count: 10, location: nil) # rubocop:disable Metrics/ParameterLists
+        error_message = validate_inputs!(place_ids: place_ids, place_type: place_type, max_count: max_count, location: location)
+        return failure(nil, error_message) if error_message
+
+        created_vendor_places = []
+
+        ActiveRecord::Base.transaction do
+          place_ids.each do |place_id|
+            vendor_place = build_vendor_place(
+              vendor: vendor,
+              place_id: place_id,
+              place_type: place_type,
+              description: description,
+              location: location
+            )
+
+            vendor_place.save!
+            created_vendor_places << vendor_place
+          end
+        end
+
+        success(created_vendor_places)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(nil, e.record.errors.full_messages.to_sentence)
+      end
+
+      private
+
+      def validate_inputs!(place_ids:, place_type:, max_count:, location: nil)
+        validate_place_type!(place_type) ||
+          (place_ids.blank? && I18n.t('controller.vendor_places.place_ids_blank')) ||
+          (place_ids.size > max_count && I18n.t('controller.vendor_places.selection_limit', count: max_count)) ||
+          (requires_location?(place_type: place_type) && location.blank? && I18n.t('controller.vendor_places.location_required'))
+      end
+
+      def build_vendor_place(vendor:, place_id:, place_type:, description:, location: nil)
+        attrs = { vendor_id: vendor.id, place_type: place_type.to_sym, place_id: place_id, description: description }
+        attrs[:location_id] = location&.id if requires_location?(place_type: place_type)
+        SpreeCmCommissioner::VendorPlace.new(attrs)
+      end
+
+      def requires_location?(place_type:)
+        %i[stop branch].include?(place_type.to_sym)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/vendor_places/create_with_google_map_data.rb

@@ -0,0 +1,85 @@
+# Creates a vendor place from Google Map base64-encoded place data.
+# Processes place data and creates both Place and VendorPlace records atomically.
+#
+# Usage:
+#   result = SpreeCmCommissioner::VendorPlaces::CreateWithGoogleMapData.call(
+#     vendor: current_vendor,
+#     place_type: 'stop',
+#     google_place_base_64_content: google_place_base_64_content,
+#     description: 'Main Warehouse',
+#     location: parent_vendor_location
+#   )
+#
+#   if result.success?
+#     vendor_place = result.value
+#   else
+#     error_message = result.error
+#   end
+
+module SpreeCmCommissioner
+  module VendorPlaces
+    class CreateWithGoogleMapData < Base
+      def call(vendor:, place_type:, google_place_base_64_content:, description: nil, location: nil)
+        error_message = validate_place_type!(place_type)
+        return failure(nil, error_message) if error_message.present?
+
+        # Only require location for stop and branch types
+        return failure(nil, I18n.t('controller.vendor_places.location_required')) if %w[stop branch].include?(place_type) && location.nil?
+
+        place = process_place(google_place_base_64_content: google_place_base_64_content)
+        return failure(nil, place) unless place.is_a?(SpreeCmCommissioner::Place)
+
+        vendor_place = create_vendor_place(vendor: vendor, place: place, place_type: place_type, description: description, location: location)
+        return failure(nil, vendor_place) if vendor_place.nil? || vendor_place.is_a?(String)
+
+        success(vendor_place)
+      end
+
+      private
+
+      def process_place(google_place_base_64_content:)
+        place = SpreeCmCommissioner::PlaceDecoder.process_place(google_place_base_64_content)
+        return I18n.t('controller.vendor_places.process_place_failed', default: 'Failed to process place') if place.nil? || !place.save
+
+        place
+      rescue StandardError => e
+        e.message
+      end
+
+      def create_vendor_place(vendor:, place:, place_type:, description:, location:)
+        error_message = nil
+        result = ActiveRecord::Base.transaction do
+          vendor_place = build_vendor_place(vendor: vendor, place: place, type: place_type, description: description, location: location)
+          unless vendor_place.save
+            error_message = vendor_place.errors.full_messages.to_sentence
+            raise ActiveRecord::Rollback
+          end
+          vendor_place
+        end
+        error_message || result
+      end
+
+      def build_vendor_place(vendor:, place:, type:, description: nil, location: nil)
+        case type
+        when 'stop'
+          vendor.stops.new(
+            place_id: place.id,
+            description: description,
+            location_id: location&.id
+          )
+        when 'branch'
+          vendor.branches.new(
+            place_id: place.id,
+            description: description,
+            location_id: location&.id
+          )
+        when 'location'
+          vendor.locations.new(
+            place_id: place.id,
+            description: description
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# Updates all vendor places matching the same vendor, place_id, and location_id.
+# Only updates description and location_id. Rolls back if any update fails.
+#
+# Usage:
+#   result = SpreeCmCommissioner::VendorPlaces::Update.call(
+#     vendor: current_vendor,
+#     vendor_place: existing_vendor_place,
+#     location_id: new_location_id,
+#     description: 'Updated description'
+#     )
+#
+#   if result.success?
+#     updated_place = result.value
+#   else
+#     error_message = result.error
+#   end
+module SpreeCmCommissioner
+  module VendorPlaces
+    class Update < Base
+      def call(vendor:, vendor_place:, description: nil, location_id: nil)
+        if vendor_place.blank?
+          return failure(
+            nil,
+            I18n.t('controller.vendor_places.vendor_place_not_found', default: 'Vendor place not found')
+          )
+        end
+
+        ActiveRecord::Base.transaction do
+          related_places = SpreeCmCommissioner::VendorPlace.where(
+            vendor_id: vendor.id,
+            place_id: vendor_place.place_id,
+            location_id: vendor_place.location_id
+          )
+
+          update_attrs = {}
+          update_attrs[:description] = description unless description.nil?
+          update_attrs[:location_id] = location_id unless location_id.nil?
+
+          related_places.each do |vp|
+            unless vp.update(update_attrs)
+              error_message = vp.errors.full_messages.to_sentence
+              raise ActiveRecord::Rollback, error_message
+            end
+          end
+        end
+
+        vendor_place.reload
+        success(vendor_place)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(nil, e.record.errors.full_messages.to_sentence)
+      rescue ActiveRecord::Rollback => e
+        failure(nil, e.message)
+      end
+    end
+  end
+end

data/app/views/spree/order_mailer/confirm_email.html.erb

@@ -16,7 +16,7 @@
               </div>
             <% else %>
               <div class="f-fallback">
-                <%= render 'spree_cm_commissioner/order_mailer/tenant/greeting', order: @order %>
+                <%= render 'spree_cm_commissioner/order_mailer/tenant/greeting', order: @order, logo: @logo, name: @name%>
                 <div class="content">
                   <%= render 'spree_cm_commissioner/order_mailer/order_total', order: @order %>
                   <%= render 'spree_cm_commissioner/order_mailer/your_booking', order: @order, show_booking_header: true %>