spree_cm_commissioner 2.0.3.pre.pre5 → 2.0.3.pre.pre.pre7

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/controllers/spree/api/v2/storefront/trip_search_controller.rb

@@ -1,60 +0,0 @@
-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],
-              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 = Spree::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/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/taxi_trip_creator.rb

@@ -1,66 +0,0 @@
-module SpreeCmCommissioner
-  class TaxiTripCreator < BaseInteractor
-    delegate :trip_params, to: :context
-
-    def call
-      ActiveRecord::Base.transaction do
-        create_trip_with_product
-        create_variant
-      end
-    end
-
-    private
-
-    def create_trip_with_product
-      trip = SpreeCmCommissioner::Trip.new(trip_params)
-
-      if trip.save
-        context.trip = trip
-        context.product = trip.product
-        assign_option_type_to_product
-        context.product.save
-      else
-        context.fail!(error: "Failed to create taxi trip: #{trip.errors.full_messages.join(', ')}")
-      end
-    end
-
-    def create_variant
-      variant = context.product.variants.new(
-        price: trip_params['product_attributes']['price'],
-        sku: "TRIP-#{context.formatted_name}-#{Time.current.to_i}",
-        option_value_ids: option_value_ids
-      )
-
-      if variant.save
-        context.variant = variant
-        create_stock_item_for_variant(variant)
-      else
-        context.fail!(error: "Failed to create taxi trip variant: #{variant.errors.full_messages.join(', ')}")
-      end
-    end
-
-    def create_stock_item_for_variant(variant)
-      stock_location = context.product.vendor.stock_location
-      if stock_location.present?
-        Spree::StockItem.find_or_create_by!(variant: variant, stock_location: stock_location) do |item|
-          item.count_on_hand = 1
-        end
-      else
-        context.fail!(error: 'Vendor does not have an active stock location.')
-      end
-    end
-
-    def assign_option_type_to_product
-      option_type = Spree::OptionType.find_by(name: 'intercity-taxi')
-      return unless option_type
-
-      context.product.option_types << option_type
-    end
-
-    def option_value_ids
-      context.product.option_types.flat_map do |option_type|
-        option_type.option_values.pluck(:id)
-      end
-    end
-  end
-end