spree_cm_commissioner 2.0.3.pre.pre → 2.0.3.pre.pre1

data/app/controllers/spree/admin/inventory_items_controller.rb

@@ -1,83 +0,0 @@
-module Spree
-  module Admin
-    class InventoryItemsController < StockManagementsController
-      before_action :load_parent
-
-      # GET /products/:slug/variants/:variant_id/inventory_items/:id
-      def show
-        @inventory_item = @product.inventory_items.find(params[:id])
-        @default_prices = @inventory_item.variant.prices.to_a.index_by(&:currency)
-
-        @prices = @inventory_item.prices.to_a
-        supported_currencies_for_all_stores.each do |currency|
-          @prices << @inventory_item.prices.new(currency: currency) if @prices.none? { |price| price.currency == currency }
-        end
-
-        @cached_inventory_item = ::SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new([@inventory_item])
-                                                                                               .call
-                                                                                               .index_by(&:inventory_item_id)[@inventory_item.id]
-      end
-
-      # POST /products/:slug/variants/:variant_id/inventory_items
-      def create
-        variant = @product.variants.find(params[:variant_id])
-        inventory_item = variant.create_default_non_permanent_inventory_item!
-
-        if inventory_item.present?
-          result = SpreeCmCommissioner::Stock::InventoryItemResetter.call(inventory_item: inventory_item)
-
-          if result.success?
-            flash[:success] = flash_message_for(result.inventory_item, :successfully_created)
-          else
-            flash[:error] = result.message
-          end
-        end
-
-        redirect_back fallback_location: admin_product_stock_managements_path(@product)
-      end
-
-      # PATCH /products/:slug/variants/:variant_id/inventory_items/:id/reset
-      def reset
-        inventory_item = @product.inventory_items.find(params[:id])
-        result = SpreeCmCommissioner::Stock::InventoryItemResetter.call(inventory_item: inventory_item)
-
-        if result.success?
-          flash[:success] = flash_message_for(result.inventory_item, :successfully_updated)
-        else
-          flash[:error] = result.message
-        end
-
-        redirect_back fallback_location: admin_product_stock_managements_path(@product)
-      end
-
-      # PATCH /products/:slug/variants/:variant_id/inventory_items/:id/update_prices
-      def update_prices
-        inventory_item = @product.inventory_items.find(params[:id])
-
-        params[:prices]&.values&.each do |price_params|
-          price = inventory_item.prices.find_or_initialize_by(currency: price_params[:currency])
-          price.price = price_params[:price].empty? ? nil : price_params[:price]
-          price.compare_at_price = price_params[:compare_at_price].empty? ? nil : price_params[:compare_at_price]
-          price.variant_id = inventory_item.variant_id
-          price.save! if (price.new_record? && price.price) || (!price.new_record? && price.changed?)
-        end
-
-        flash[:success] = flash_message_for(inventory_item, :successfully_updated)
-        redirect_back fallback_location: admin_product_stock_managements_path(@product)
-      end
-
-      # PATCH /products/:slug/variants/:variant_id/inventory_items/:id/delete_prices
-      def delete_prices
-        inventory_item = @product.inventory_items.find(params[:id])
-
-        if inventory_item.prices.destroy_all
-          flash[:success] = flash_message_for(inventory_item, :successfully_removed)
-        else
-          flash[:error] = inventory_item.errors.full_messages.join(', ')
-        end
-
-        redirect_back fallback_location: admin_product_stock_managements_path(@product)
-      end
-    end
-  end
-end

data/app/controllers/spree/api/v2/storefront/accommodations/variants_controller.rb

@@ -1,42 +0,0 @@
-module Spree
-  module Api
-    module V2
-      module Storefront
-        class Accommodations::VariantsController < ::Spree::Api::V2::ResourceController
-          private
-
-          # override
-          def collection
-            @collection ||= SpreeCmCommissioner::Accommodations::FindVariant.new(
-              from_date: params[:from_date]&.to_date,
-              to_date: params[:to_date]&.to_date,
-              vendor_id: params[:accommodation_id],
-              number_of_adults: params[:adult].to_i,
-              number_of_kids: params[:children].to_i
-            ).execute
-          end
-
-          # override
-          def resource
-            @resource ||= collection.find(params[:id])
-          end
-
-          # override
-          def resource_serializer
-            Spree::V2::Storefront::VariantSerializer
-          end
-
-          # override
-          def collection_serializer
-            Spree::V2::Storefront::VariantSerializer
-          end
-
-          # override
-          def required_schema
-            SpreeCmCommissioner::VariantRequestSchema
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/ensure_correct_product_type.rb

@@ -1,40 +0,0 @@
-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/inventory_item_syncer.rb

@@ -1,25 +0,0 @@
-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

data/app/interactors/spree_cm_commissioner/stock/inventory_item_resetter.rb

@@ -1,44 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemResetter < BaseInteractor
-      delegate :inventory_item, to: :context
-
-      def call
-        max_capacity = variant_total_inventory
-        total_purchases = variant_total_purchases
-        quantity_available = [max_capacity - total_purchases, 0].max
-
-        updated = inventory_item.update(max_capacity: max_capacity, quantity_available: quantity_available)
-        return context.fail!(message: 'Failed to update inventory item', errors: inventory_item.errors.full_messages) unless updated
-
-        clear_inventory_cache
-      end
-
-      def variant_total_inventory
-        # for shipment, total_on_hand is not orignal stock. shipment does subtract the stock.
-        # to get desire result, we need to add to total_purchase.
-        if inventory_item.variant.delivery_required?
-          inventory_item.variant.total_on_hand.to_i + variant_total_purchases
-        else
-          inventory_item.variant.total_on_hand.to_i
-        end
-      end
-
-      def variant_total_purchases
-        scope = inventory_item.variant.complete_line_items
-
-        if inventory_item.permanent_stock?
-          scope.where('? BETWEEN from_date AND to_date', inventory_item.inventory_date).sum(:quantity).to_i
-        else
-          scope.sum(:quantity).to_i
-        end
-      end
-
-      def clear_inventory_cache
-        SpreeCmCommissioner.redis_pool.with do |redis|
-          redis.del(inventory_item.redis_key)
-        end
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/inventory_items_adjuster.rb

@@ -1,13 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsAdjuster < BaseInteractor
-      delegate :variant, :quantity, to: :context
-
-      def call
-        variant.inventory_items.active.find_each do |inventory_item|
-          inventory_item.adjust_quantity!(quantity)
-        end
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/inventory_items_generator.rb

@@ -1,15 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsGenerator < BaseInteractor
-      delegate :variant, to: :context
-
-      def call
-        if variant.permanent_stock?
-          SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call(variant_ids: [variant.id])
-        else
-          variant.create_default_non_permanent_inventory_item! unless variant.default_inventory_item_exist?
-        end
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/permanent_inventory_items_generator.rb

@@ -1,75 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class PermanentInventoryItemsGenerator < BaseInteractor
-      delegate :variant_ids, to: :context
-
-      def variants_per_batch = 1000
-
-      def pre_inventory_days_for(variant)
-        context.pre_inventory_days || variant.pre_inventory_days
-      end
-
-      def call
-        variants.in_batches(of: variants_per_batch) do |batch|
-          generate_inventory_items_for_batch(batch)
-        end
-      end
-
-      private
-
-      def generate_inventory_items_for_batch(batch)
-        total_on_hand_by_variant = total_on_hand_for(batch)
-        batch.each do |variant|
-          count_on_hand = total_on_hand_by_variant[variant.id] || 0
-          generate_inventory_items_for_variant(variant, count_on_hand)
-        end
-      end
-
-      def generate_inventory_items_for_variant(variant, count_on_hand)
-        inventory_dates_for(variant).each do |inventory_date|
-          next if inventory_exist?(variant, inventory_date)
-
-          create_inventory_item(variant, inventory_date, count_on_hand)
-        end
-      end
-
-      def inventory_dates_for(variant)
-        start_date = Time.zone.tomorrow
-        end_date = Time.zone.today + pre_inventory_days_for(variant)
-
-        (start_date..end_date)
-      end
-
-      def inventory_exist?(variant, inventory_date)
-        variant.inventory_items.exists?(inventory_date: inventory_date)
-      end
-
-      def create_inventory_item(variant, inventory_date, count_on_hand)
-        variant.inventory_items.create!(
-          inventory_date: inventory_date,
-          quantity_available: count_on_hand,
-          max_capacity: count_on_hand,
-          product_type: variant.product_type
-        )
-      end
-
-      # Returns a hash: { variant_id => total_on_hand, ... }
-      def total_on_hand_for(variants)
-        variant_ids = variants.pluck(:id)
-
-        Spree::StockItem
-          .joins(:stock_location)
-          .where(deleted_at: nil, variant_id: variant_ids)
-          .where(spree_stock_locations: { active: true })
-          .group(:variant_id)
-          .sum(:count_on_hand)
-      end
-
-      def variants
-        scope = Spree::Variant.active.with_permanent_stock.where(is_master: false)
-        scope = scope.where(id: variant_ids) if variant_ids.present?
-        scope
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/stock/stock_movement_creator.rb

@@ -1,32 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class StockMovementCreator < BaseInteractor
-      delegate :variant_id, :stock_location_id, :current_store, :stock_movement_params, to: :context
-
-      def call
-        variant = current_store.variants.find(variant_id)
-
-        return context.fail!(message: Spree.t(:doesnt_track_inventory)) unless variant.track_inventory?
-
-        stock_location = Spree::StockLocation.find(stock_location_id)
-        stock_movement = stock_location.stock_movements.build(stock_movement_params)
-        stock_movement.stock_item = stock_location.set_up_stock_item(variant)
-
-        if stock_movement.save
-          adjust_inventory_items_async(variant_id, stock_movement.quantity)
-          context.stock_movement = stock_movement
-        else
-          context.fail!(message: stock_movement.errors.full_messages.join(', '))
-        end
-      end
-
-      private
-
-      def adjust_inventory_items_async(variant_id, quantity)
-        CmAppLogger.log(label: "#{self.class.name}#adjust_inventory_items_async", data: { variant_id: variant_id, quantity: quantity }) do
-          SpreeCmCommissioner::Stock::InventoryItemsAdjusterJob.perform_later(variant_id: variant_id, quantity: quantity)
-        end
-      end
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/variant_block_updater.rb

@@ -1,62 +0,0 @@
-module SpreeCmCommissioner
-  class VariantBlockUpdater < BaseInteractor
-    delegate :variant, :data, :stock_location, :current_store, to: :context
-
-    def call
-      block_ids = data[:block_ids] || []
-
-      ActiveRecord::Base.transaction do
-        update_variant_block!(block_ids, variant)
-        update_stock_item!(variant)
-      end
-
-      context.message = 'Update variant blocks successfully'
-    rescue StandardError => e
-      context.fail!(message: "Update variant blocks Failed: #{e.message}")
-    end
-
-    private
-
-    def update_variant_block!(block_ids, variant)
-      variant.variant_blocks.where.not(block_id: block_ids).destroy_all
-
-      block_ids.each do |block_id|
-        next unless SpreeCmCommissioner::Block.exists?(id: block_id) # Skip invalid block_ids
-
-        block = SpreeCmCommissioner::VariantBlock.find_by(
-          block_id: block_id,
-          trip_id: variant.product.trip.id,
-          variant_id: variant.id
-        )
-
-        next unless block.nil?
-
-        SpreeCmCommissioner::VariantBlock.create!(
-          block_id: block_id,
-          trip_id: variant.product.trip.id,
-          variant_id: variant.id
-        )
-      end
-    end
-
-    def update_stock_item!(variant)
-      stock_items = variant.stock_items
-
-      context.fail!(message: 'Variant has more than one stock item. Please report to admin.') if stock_items.count > 1
-
-      stock_item = stock_items.first || variant.stock_items.create!(stock_location: stock_location)
-      quantity_difference = variant.variant_blocks.count - stock_item.count_on_hand
-
-      resource = SpreeCmCommissioner::Stock::StockMovementCreator.call(
-        variant_id: variant.id,
-        stock_location_id: stock_location.id,
-        current_store: current_store,
-        stock_movement_params: { quantity: quantity_difference }
-      )
-
-      return if resource.success?
-
-      context.fail!(message: "Stock update failed: #{resource.errors}")
-    end
-  end
-end

data/app/interactors/spree_cm_commissioner/vehicle_updater.rb

@@ -1,41 +0,0 @@
-module SpreeCmCommissioner
-  class VehicleUpdater < BaseInteractor
-    def call
-      vehicle = context.vehicle
-      data    = context.data
-
-      option_value_ids = data[:option_value_ids] || []
-      option_type_ids  = data[:option_type_ids] || []
-
-      ActiveRecord::Base.transaction do
-        update_vehicle!(vehicle, data[:vehicle_attributes])
-        update_amenities!(vehicle, option_value_ids, option_type_ids)
-      end
-
-      context.message = I18n.t('views.transit.vehicles.update_success')
-    rescue StandardError => e
-      context.fail!(message: "Failed to update vehicle: #{e.message}")
-    end
-
-    private
-
-    def update_vehicle!(vehicle, attributes)
-      return if vehicle.update(attributes.slice(:code, :license_plate, :allow_seat_selection, :vehicle_type, :number_of_seats))
-
-      raise vehicle.errors.full_messages.to_sentence
-    end
-
-    def update_amenities!(vehicle, option_value_ids, option_type_ids)
-      vehicle.option_value_vehicles.where.not(option_value_id: option_value_ids).destroy_all
-      vehicle.vehicle_option_types.where.not(option_type_id: option_type_ids).destroy_all
-
-      option_value_ids.each do |option_value_id|
-        vehicle.option_value_vehicles.find_or_create_by(option_value_id: option_value_id)
-      end
-
-      option_type_ids.each do |option_type_id|
-        vehicle.vehicle_option_types.find_or_create_by(option_type_id: option_type_id)
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/ensure_correct_product_type_job.rb

@@ -1,7 +0,0 @@
-module SpreeCmCommissioner
-  class EnsureCorrectProductTypeJob < ApplicationJob
-    def perform
-      SpreeCmCommissioner::EnsureCorrectProductType.call
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/inventory_item_syncer_job.rb

@@ -1,7 +0,0 @@
-module SpreeCmCommissioner
-  class InventoryItemSyncerJob < ApplicationUniqueJob
-    def perform(inventory_id_and_quantities:)
-      InventoryItemSyncer.call(inventory_id_and_quantities:)
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/stock/inventory_items_adjuster_job.rb

@@ -1,11 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsAdjusterJob < ApplicationUniqueJob
-      def perform(variant_id:, quantity:)
-        variant = Spree::Variant.find(variant_id)
-
-        SpreeCmCommissioner::Stock::InventoryItemsAdjuster.call(variant: variant, quantity: quantity)
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/stock/inventory_items_generator_job.rb

@@ -1,11 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class InventoryItemsGeneratorJob < ApplicationUniqueJob
-      def perform(variant_id:)
-        variant = Spree::Variant.find(variant_id)
-
-        SpreeCmCommissioner::Stock::InventoryItemsGenerator.call(variant: variant)
-      end
-    end
-  end
-end

data/app/jobs/spree_cm_commissioner/stock/permanent_inventory_items_generator_job.rb

@@ -1,9 +0,0 @@
-module SpreeCmCommissioner
-  module Stock
-    class PermanentInventoryItemsGeneratorJob < ApplicationUniqueJob
-      def perform
-        SpreeCmCommissioner::Stock::PermanentInventoryItemsGenerator.call
-      end
-    end
-  end
-end

data/app/models/concerns/spree_cm_commissioner/order_seatable.rb

@@ -1,44 +0,0 @@
-module SpreeCmCommissioner
-  module OrderSeatable
-    def should_manage_blocks?
-      preload_block_ids.any?
-    end
-
-    def hold_blocks!
-      return unless should_manage_blocks?
-
-      CmAppLogger.log(label: "#{self.class.name}#hold_blocks!", data: { order_id: id }) do
-        SpreeCmCommissioner::Seats::BlocksHolder.new(line_item_ids: line_item_ids, hold_by: user).hold_blocks!
-      end
-    end
-
-    def cancel_blocks!
-      return unless should_manage_blocks?
-
-      CmAppLogger.log(label: "#{self.class.name}#cancel_blocks!", data: { order_id: id }) do
-        SpreeCmCommissioner::Seats::BlocksCanceler.new(order_id: id, cancel_by: user).cancel_blocks!
-      end
-    end
-
-    def reserve_blocks!
-      return unless should_manage_blocks?
-
-      CmAppLogger.log(label: "#{self.class.name}#reserve_blocks!", data: { order_id: id }) do
-        SpreeCmCommissioner::Seats::BlocksReserver.new(line_item_ids: line_item_ids, reserve_by: user).reserve_blocks!
-      end
-    end
-
-    # Calling `.block_ids` directly can cause many slow database queries (N+1 problem)
-    # every time `.should_manage_blocks?` or `.preload_block_ids` runs.
-    # To avoid this, we store a precomputed list of block IDs in `private_metadata`.
-    # This list is updated whenever a guest’s block is saved or destroy.
-    def preload_block_ids=(preload_block_ids = [])
-      self.private_metadata ||= {}
-      self.private_metadata['preload_block_ids'] = preload_block_ids
-    end
-
-    def preload_block_ids
-      self.private_metadata&.fetch('preload_block_ids', []) || []
-    end
-  end
-end

data/app/models/concerns/spree_cm_commissioner/vehicle_type.rb

@@ -1,11 +0,0 @@
-module SpreeCmCommissioner
-  module VehicleType
-    extend ActiveSupport::Concern
-
-    VEHICLE_TYPES = %i[suv sedan minivan van sleeping_bus luxury_van air_bus].freeze
-
-    included do
-      enum vehicle_type: VEHICLE_TYPES if table_exists? && column_names.include?('vehicle_type')
-    end
-  end
-end