spree_cm_commissioner 2.0.3.pre.pre.pre7 → 2.1.0.pre.pre1

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

@@ -32,7 +32,7 @@ module Spree
               resource.save_and_move_to_next_stage
               render_serialized_payload(201) { serialize_resource(resource) }
             else
-              render_error_payload(resource.errors, 400)
+              render_error_payload(resource.errors, 422)
             end
           end
 
@@ -41,15 +41,7 @@ module Spree
 
             begin
               ActiveRecord::Base.transaction do
-                if guest_params[:guest_dynamic_fields_attributes]
-                  dynamic_field_ids = guest_params[:guest_dynamic_fields_attributes].pluck(:dynamic_field_id)
-                  resource.guest_dynamic_fields.where(dynamic_field_id: dynamic_field_ids).destroy_all
-
-                  guest_params[:guest_dynamic_fields_attributes].each do |attr|
-                    field = build_dynamic_field(attr)
-                    field.save!
-                  end
-                end
+                process_dynamic_fields(guest_params[:guest_dynamic_fields_attributes]) if guest_params[:guest_dynamic_fields_attributes]
 
                 resource.assign_attributes(guest_params.except(:guest_dynamic_fields_attributes))
                 resource.save!
@@ -58,7 +50,7 @@ module Spree
               resource.save_and_move_to_next_stage
               render_serialized_payload { serialize_resource(resource) }
             rescue ActiveRecord::RecordInvalid => e
-              render_error_payload(e.record.errors, 400)
+              render_error_payload(e.record.errors, 422)
             end
           end
 
@@ -97,15 +89,31 @@ module Spree
             )
           end
 
-          def build_dynamic_field(attr)
-            field = resource.guest_dynamic_fields.build(attr.except(:id))
-
-            if field.dynamic_field.requires_dynamic_field_options?
-              option = field.dynamic_field.dynamic_field_options.find_by(id: field.value)
-              field.dynamic_field_option = option if option
+          def process_dynamic_fields(dynamic_fields_attributes)
+            dynamic_fields_attributes.each do |attr|
+              if attr[:_destroy] == '1' && attr[:id].present?
+                field = resource.guest_dynamic_fields.find_by(id: attr[:id])
+                field&.destroy!
+              elsif attr[:id].present?
+                field = resource.guest_dynamic_fields.find_by(id: attr[:id])
+                if field
+                  field.assign_attributes(attr.except(:id, :_destroy))
+                  associate_dynamic_field_option(field) if field.dynamic_field.present?
+                  field.save!
+                end
+              else
+                field = resource.guest_dynamic_fields.build(attr.except(:id, :_destroy))
+                associate_dynamic_field_option(field) if field.dynamic_field.present?
+                field.save!
+              end
             end
+          end
+
+          def associate_dynamic_field_option(field)
+            return unless field.dynamic_field&.requires_dynamic_field_options?
 
-            field
+            option = field.dynamic_field.dynamic_field_options.find_by(id: field.value)
+            field.dynamic_field_option = option if option
           end
         end
       end

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

@@ -0,0 +1,57 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class InventoryItemsController < ::Spree::Api::V2::ResourceController
+          # GET /api/v2/storefront/inventory_items?
+          # - variant_ids[]=[1,2]
+          # - inventory_dates[]=[2025-03-06] (optional)
+          # - includes[]=reserved_blocks
+          def index
+            render_serialized_payload do
+              collection_serializer.new(
+                collection,
+                { include: resource_includes, params: serializer_params }
+              ).serializable_hash
+            end
+          end
+
+          # override
+          def collection
+            return @collection if defined?(@collection)
+
+            scope = if include_reserved_blocks?
+                      SpreeCmCommissioner::InventoryItem.includes(:prices, :reserved_blocks)
+                    else
+                      SpreeCmCommissioner::InventoryItem.includes(:prices)
+                    end
+
+            @collection = scope.where(variant_id: params[:variant_ids], inventory_date: params[:inventory_dates])
+            @collection
+          end
+
+          # override
+          def collection_serializer
+            SpreeCmCommissioner::V2::Storefront::InventoryItemSerializer
+          end
+
+          # override
+          def required_schema
+            SpreeCmCommissioner::InventoryItemSchema
+          end
+
+          # override
+          def serializer_params
+            super.merge(include_reserved_blocks: include_reserved_blocks?)
+          end
+
+          private
+
+          def include_reserved_blocks?
+            resource_includes.include?(:reserved_blocks)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/queue_cart/line_items_controller.rb

@@ -12,9 +12,9 @@ module Spree
               spree_authorize! :update, spree_current_order, order_token
               spree_authorize! :show, @variant
 
-              availability_checker = SpreeCmCommissioner::Stock::AvailabilityChecker.new(@variant)
+              availability_checker = SpreeCmCommissioner::Stock::AvailabilityChecker.new(@variant, add_item_params[:options])
 
-              unless availability_checker.can_supply?(add_item_params[:quantity].to_i, add_item_params[:options])
+              unless availability_checker.can_supply?(add_item_params[:quantity].to_i)
                 return render_error_payload(availability_checker.error_message || I18n.t('variant_availability.items_out_of_stock'))
               end
 

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

@@ -0,0 +1,46 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Transit
+          class DraftOrdersController < ::Spree::Api::V2::ResourceController
+            # Creates a draft transit order.
+            # Endpoint: POST /api/v2/storefront/transit/draft_orders
+            # Params:
+            # - outbound_date: Date of outbound transit (optional)
+            # - inbound_date: Date of inbound transit (optional)
+            # - outbound_legs: Array of outbound leg details (required)
+            # - inbound_legs: Array of inbound leg details (optional)
+            def create
+              @outbound_legs = params[:outbound_legs].is_a?(Array) && params[:outbound_legs].any? ? build_legs(:outbound, params[:outbound_legs]) : []
+              @inbound_legs  = params[:inbound_legs].is_a?(Array) && params[:inbound_legs].any? ? build_legs(:inbound, params[:inbound_legs]) : []
+
+              context = SpreeCmCommissioner::Transit::DraftOrderCreator.call(
+                outbound_date: params[:outbound_date]&.to_date,
+                inbound_date: params[:inbound_date]&.to_date,
+                outbound_legs: @outbound_legs,
+                inbound_legs: @inbound_legs,
+                user: spree_current_user
+              )
+
+              if context.success?
+                render_serialized_payload { serialize_resource(context.order) }
+              else
+                render_error_payload(context.message)
+              end
+            end
+
+            def build_legs(direction, legs_params)
+              SpreeCmCommissioner::Transit::LegsBuilderService.new(direction: direction, legs_params: legs_params).call
+            end
+
+            # override
+            def resource_serializer
+              Spree::Api::Dependencies.storefront_cart_serializer.constantize
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class TripPlacesController < ::Spree::Api::V2::ResourceController
+          # override
+          def collection
+            base_scope = model_class.joins(:location_vendor_places).distinct
+
+            if params[:q].present?
+              @search = base_scope.ransack(params[:q])
+              @search.result
+            else
+              base_scope
+            end
+          end
+
+          def model_class
+            SpreeCmCommissioner::Place
+          end
+
+          def collection_serializer
+            SpreeCmCommissioner::V2::Storefront::TripPlaceSerializer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class TripSearchController < ::Spree::Api::V2::ResourceController
+          def index
+            trips = SpreeCmCommissioner::TripQuery.new(
+              origin_id: params[:origin_id],
+              destination_id: params[:destination_id],
+              date: params[:date],
+              vendor_id: params[:vendor_id],
+              number_of_guests: params[:number_of_guests],
+              params: params
+            ).call
+
+            render_serialized_payload { serialize_collection(trips) }
+          end
+
+          private
+
+          # override
+          def default_resource_includes
+            [
+              'trips.vendor',
+              'trips.vendor.logo',
+              'trips.vehicle',
+              'trips.amenities'
+            ]
+          end
+
+          def serialize_collection(collection)
+            serialized_data = SpreeCmCommissioner::V2::Storefront::TripQueryResultSerializer.new(
+              collection,
+              include: default_resource_includes,
+              params: serializer_params
+            ).serializable_hash
+            serialized_data[:meta] = {
+              count: collection.size,
+              total_count: collection.respond_to?(:total_count) ? collection.total_count : collection.size,
+              current_page: collection.respond_to?(:current_page) ? collection.current_page : 1,
+              per_page: collection.respond_to?(:limit_value) ? collection.limit_value : collection.size,
+              pages: collection.respond_to?(:total_pages) ? collection.total_pages : 1,
+              next_page: collection.respond_to?(:next_page) ? collection.next_page : nil,
+              prev_page: collection.respond_to?(:prev_page) ? collection.prev_page : nil
+            }
+            serialized_data
+          end
+
+          # override
+          def serializer_params
+            params.permit(:include).to_hash
+          end
+
+          # override
+          def required_schema
+            SpreeCmCommissioner::TripSearchRequestSchema
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class TripsController < ::Spree::Api::V2::ResourceController
+          # override
+          def resource
+            model_class.find(params[:id])
+          end
+
+          # override
+          def model_class
+            SpreeCmCommissioner::Trip
+          end
+
+          # override
+          def resource_serializer
+            SpreeCmCommissioner::V2::Storefront::TripSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/finders/spree_cm_commissioner/accommodations/find.rb

@@ -0,0 +1,37 @@
+module SpreeCmCommissioner
+  module Accommodations
+    class Find
+      attr_reader :from_date, :to_date, :state_id, :number_of_guests
+
+      def initialize(from_date:, to_date:, state_id:, number_of_adults:, number_of_kids:)
+        @from_date = from_date
+        @to_date = to_date
+        @state_id = state_id
+        @number_of_guests = number_of_adults.to_i + number_of_kids.to_i
+      end
+
+      def execute
+        scope
+          .where(default_state_id: state_id)
+          .where(inventory_items: { inventory_date: stay_dates })
+          .where('CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-adults\' AS INTEGER) +
+                  CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-kids\' AS INTEGER) >= ?', number_of_guests
+          )
+          .where('inventory_items.quantity_available > 0')
+          .distinct
+      end
+
+      private
+
+      def scope
+        Spree::Vendor
+          .joins(variants: :inventory_items)
+          .where(primary_product_type: :accommodation, state: :active)
+      end
+
+      def stay_dates
+        from_date..to_date
+      end
+    end
+  end
+end

data/app/finders/spree_cm_commissioner/accommodations/find_variant.rb

@@ -0,0 +1,32 @@
+module SpreeCmCommissioner
+  module Accommodations
+    class FindVariant
+      attr_reader :vendor_id, :from_date, :to_date, :number_of_guests
+
+      def initialize(vendor_id:, from_date:, to_date:, number_of_adults:, number_of_kids:)
+        @vendor_id = vendor_id
+        @from_date = from_date
+        @to_date = to_date
+        @number_of_guests = number_of_adults.to_i + number_of_kids.to_i
+      end
+
+      def execute
+        Spree::Variant
+          .joins(:inventory_items)
+          .where(vendor_id: vendor_id)
+          .where(inventory_items: { inventory_date: stay_dates })
+          .where('CAST(public_metadata->\'cm_options\'->>\'number-of-adults\' AS INTEGER) +
+                  CAST(public_metadata->\'cm_options\'->>\'number-of-kids\' AS INTEGER) >= ?', number_of_guests
+          )
+          .where('inventory_items.quantity_available > 0')
+          .distinct
+      end
+
+      private
+
+      def stay_dates
+        from_date..to_date
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/billing_address_creator.rb

@@ -0,0 +1,33 @@
+module SpreeCmCommissioner
+  class BillingAddressCreator < BaseInteractor
+    delegate :order, to: :context
+
+    def call
+      validate_context!
+      create_address
+    end
+
+    private
+
+    def validate_context!
+      context.fail!(message: 'Order is missing') unless order
+    end
+
+    def create_address
+      line_item = order.line_items.first
+      guest = line_item&.guests&.first
+
+      billing_address = order.build_bill_address(
+        firstname: guest&.first_name,
+        lastname: guest&.last_name,
+        phone: order.intel_phone_number || order.phone_number
+      )
+
+      context.fail!(message: billing_address.errors.full_messages.to_sentence) unless billing_address.save!
+      # Persist association on the order so subsequent reloads reflect the new billing address
+      order.update!(bill_address: billing_address)
+
+      context.billing_address = billing_address
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/customer_notification_sender.rb

@@ -55,7 +55,8 @@ module SpreeCmCommissioner
     end
 
     def end_users
-      users_scope = Spree.user_class.where(tenant_id: customer_notification.tenant_id)
+      users_scope = Spree.user_class
+                         .where(tenant_id: notification_tenant_id)
 
       if customer_notification.notification_taxons.exists?
         taxon_ids = customer_notification.notification_taxons.pluck(:taxon_id)
@@ -63,12 +64,16 @@ module SpreeCmCommissioner
                       .new(taxon_ids)
                       .call
                       .end_users_push_notificable
-                      .where(tenant_id: customer_notification.tenant_id)
+                      .where(tenant_id: notification_tenant_id)
       else
         users_scope = users_scope.end_users_push_notificable
       end
 
       users_scope
     end
+
+    def notification_tenant_id
+      @notification_tenant_id ||= customer_notification.vendor&.tenant_id
+    end
   end
 end

data/app/interactors/spree_cm_commissioner/ensure_correct_product_type.rb

@@ -0,0 +1,40 @@
+module SpreeCmCommissioner
+  class EnsureCorrectProductType < BaseInteractor
+    def call
+      Spree::Product
+        .left_joins(variants_including_master: %i[inventory_items line_items])
+        .where(
+          'spree_variants.product_type IS NULL OR
+          spree_variants.product_type != spree_products.product_type OR
+
+          cm_inventory_items.product_type IS NULL OR
+          cm_inventory_items.product_type != spree_products.product_type OR
+
+          spree_line_items.product_type IS NULL OR
+          spree_line_items.product_type != spree_products.product_type OR
+
+          spree_products.product_type IS NOT NULL
+          '
+        )
+        .distinct.find_each do |product|
+        sync_product_type_for(product)
+      end
+    end
+
+    def sync_product_type_for(product)
+      product_type = Spree::Variant.product_types[product.product_type]
+
+      product.variants_including_master
+             .where('spree_variants.product_type IS NULL OR spree_variants.product_type != ?', product_type)
+             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
+
+      product.line_items
+             .where('spree_line_items.product_type IS NULL OR spree_line_items.product_type != ?', product_type)
+             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
+
+      product.inventory_items
+             .where('cm_inventory_items.product_type IS NULL OR cm_inventory_items.product_type != ?', product_type)
+             .update_all(product_type: product_type) # rubocop:disable Rails/SkipsModelValidations
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/fetch_facebook_user_data.rb

@@ -0,0 +1,45 @@
+module SpreeCmCommissioner
+  class FetchFacebookUserData < BaseInteractor
+    delegate :fb_access_token, to: :context
+
+    def call
+      context.fail!(message: 'fb_access_token_missing') if fb_access_token.blank?
+
+      graph_response = fetch_user_info
+
+      context.fail!(message: 'invalid_facebook_response') unless graph_response.is_a?(Hash)
+      context.fail!(message: graph_response['error']['message'] || 'facebook_error') if graph_response['error']
+
+      context.provider = {
+        identity_type: SpreeCmCommissioner::UserIdentityProvider.identity_types[:facebook],
+        sub: graph_response['id'],
+        name: graph_response['name'],
+        email: graph_response['email'], # can be nil
+        first_name: graph_response['first_name'],
+        last_name: graph_response['last_name'],
+        picture: graph_response.dig('picture', 'data', 'url')
+      }
+    end
+
+    private
+
+    def fetch_user_info
+      uri = URI('https://graph.facebook.com/v23.0/me')
+      uri.query = URI.encode_www_form(
+        fields: 'id,email,first_name,last_name,name,picture',
+        access_token: fb_access_token
+      )
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = 5
+      http.read_timeout = 10
+
+      response = http.get(uri.request_uri)
+      JSON.parse(response.body)
+    rescue StandardError => e
+      CmAppLogger.error("Facebook API error: #{e.message}")
+      context.fail!(message: 'facebook_api_error', error: e.message)
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/google_places_fetcher.rb

@@ -11,6 +11,7 @@ module SpreeCmCommissioner
           types: json['types'].blank? ? '' : json['types'][0],
           name: json['name'],
           vicinity: json['vicinity'],
+          formatted_address: json['formatted_address'],
           lat: json['geometry']['location']['lat'],
           lon: json['geometry']['location']['lng'],
           icon: json['icon'],

data/app/interactors/spree_cm_commissioner/intercity_taxi_order_creator.rb

@@ -0,0 +1,106 @@
+module SpreeCmCommissioner
+  class IntercityTaxiOrderCreator < BaseInteractor
+    delegate :trip, :raw_params, :current_vendor, to: :context
+
+    def call
+      validate_context!
+
+      ActiveRecord::Base.transaction do
+        build_order_params
+        create_order
+        create_billing_address
+        advance_order
+      end
+    end
+
+    private
+
+    def validate_context!
+      context.fail!(message: 'Trip is missing') unless trip
+      context.fail!(message: 'Raw parameters are missing') unless raw_params
+      context.fail!(message: 'Current vendor is missing') unless current_vendor
+    end
+
+    def build_order_params
+      context.order_params = build_taxi_booking_params
+    end
+
+    def build_taxi_booking_params
+      permitted_params = raw_params.require(:order).permit(
+        :intel_phone_number,
+        :email,
+        :store_id,
+        line_items_attributes: [
+          :remark,
+          :variant_id,
+          :quantity,
+          :vendor_id,
+          :from_date,
+          :to_date,
+          :currency,
+          :direction,
+          :trip_id,
+          :pickup_place_name,
+          :drop_off_place_name,
+          :pickup_lat,
+          :pickup_lng,
+          :drop_off_lat,
+          :drop_off_lng,
+          :passenger_count,
+          :pickup_oob_confirmed,
+          :drop_off_oob_confirmed,
+          { guests_attributes: %i[
+            first_name last_name gender age nationality_id
+          ]
+}
+        ]
+      )
+
+      process_line_items_attributes(permitted_params)
+      permitted_params
+    end
+
+    def process_line_items_attributes(params)
+      date_param = raw_params[:date] || Date.current.to_s
+
+      params[:line_items_attributes].each_value do |item|
+        pickup_time_minutes = item[:from_date]
+        combined_datetime = "#{date_param} #{pickup_time_minutes}"
+
+        item[:from_date] = combined_datetime
+        item[:to_date] = combined_datetime
+        item[:variant_id] = load_variant
+        item[:vendor_id] = current_vendor.id
+        item[:quantity] = 1
+        item[:currency] = 'USD'
+        item[:direction] = 'outbound'
+        item[:trip_id] = trip.id
+      end
+    end
+
+    def create_order
+      context.order = Spree::Order.create(context.order_params)
+
+      context.fail!(message: context.order.errors.full_messages.to_sentence) unless context.order.persisted?
+    end
+
+    def create_billing_address
+      return if context.order.bill_address.present?
+
+      SpreeCmCommissioner::BillingAddressCreator.call(
+        order: context.order
+      )
+    end
+
+    def advance_order
+      context.order.update_with_updater!
+
+      advance_service = Spree::Api::Dependencies.storefront_checkout_advance_service.constantize
+      advance_service.call(order: context.order)
+    end
+
+    def load_variant
+      trip.product.master.id
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/inventory_item_syncer.rb

@@ -0,0 +1,25 @@
+module SpreeCmCommissioner
+  class InventoryItemSyncer < BaseInteractor
+    # inventory_id_and_quantities = [{ inventory_id: inventory_item1.id, quantity: 5 } ]
+    delegate :inventory_id_and_quantities, to: :context
+
+    def call
+      ActiveRecord::Base.transaction do
+        inventory_items.each do |inventory_item|
+          quantity = inventory_id_and_quantities.find { |item| item[:inventory_id] == inventory_item.id }&.dig(:quantity) || 0
+          adjust_quantity_available(inventory_item, quantity)
+        end
+      end
+    end
+
+    private
+
+    def adjust_quantity_available(inventory_item, quantity)
+      inventory_item.update!(quantity_available: inventory_item.quantity_available + quantity)
+    end
+
+    def inventory_items
+      @inventory_items ||= InventoryItem.where(id: inventory_id_and_quantities.pluck(:inventory_id))
+    end
+  end
+end