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

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

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

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

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

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

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

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

data/app/interactors/spree_cm_commissioner/transit/draft_order_creator.rb

@@ -0,0 +1,136 @@
+# DraftOrderCreator creates a new order for a entire journey, including outbound and (if present) inbound directions.
+#
+# Attributes:
+# - outbound_date: [Date] The date of outbound transit
+# - inbound_date:  [Date] The date of inbound transit
+# - outbound_legs: [Array<SpreeCmCommissioner::Transit::Leg>] Outbound transit legs (one for direct, multiple for connecting)
+# - inbound_legs:  [Array<SpreeCmCommissioner::Transit::Leg>] Inbound transit legs (one for direct, multiple for connecting)
+# - user:          [User] The user for whom the order is being created
+#
+# Each line item is built with precise from_date and to_date based on legs and trip stop times.
+# Each line item has guests built corresponding to seat selection blocks.
+#
+# Note: inbound_legs and inbound_date are optional; the order may represent a one-way (outbound only) journey.
+module SpreeCmCommissioner
+  module Transit
+    class DraftOrderCreator < BaseInteractor
+      delegate :outbound_date,
+               :inbound_date,
+               :outbound_legs,
+               :inbound_legs,
+               :user, to: :context
+
+      def call
+        return context.fail!(message: 'Outbound legs are missing') if outbound_legs.blank?
+
+        begin
+          context.order = create_order!
+        rescue StandardError => e
+          context.fail!(message: e.message)
+        end
+      end
+
+      def create_order!
+        order = Spree::Order.new(state: 'cart', use_billing: true, user: user)
+
+        outbound_line_items = build_line_items_for_legs!(order: order, legs: outbound_legs, initial_date: outbound_date)
+        inbound_line_items = inbound_legs.blank? ? [] : build_line_items_for_legs!(order: order, legs: inbound_legs, initial_date: inbound_date)
+
+        outbound_qty = outbound_line_items.sum(&:quantity)
+        inbound_qty = inbound_line_items.sum(&:quantity)
+
+        raise StandardError, 'Outbound & inbound line item quantities do not match' if inbound_line_items.any? && outbound_qty != inbound_qty
+        raise StandardError, order.errors.full_messages.to_sentence unless order.save
+
+        order.update_with_updater!
+        order
+      end
+
+      # Build line items for each leg, using the previous leg's to_date as the next leg's date,
+      # or the initial date for the first leg.
+      def build_line_items_for_legs!(order:, legs:, initial_date:)
+        all_line_items = []
+        current_leg_date = initial_date
+
+        legs.each do |leg|
+          leg_line_items = build_line_items_for!(leg, order, current_leg_date)
+          leg_line_items = insert_saved_guests_per_line_items_leg(leg_line_items)
+
+          all_line_items.concat(leg_line_items)
+          current_leg_date = leg_line_items.last.to_date.to_date if leg_line_items.any?
+        end
+
+        all_line_items
+      end
+
+      def build_line_items_for!(leg, order, date)
+        trip = SpreeCmCommissioner::Trip.find(leg.trip_id)
+        trip_stops = trip.trip_stops.where(id: [leg.boarding_trip_stop_id, leg.drop_off_trip_stop_id]).index_by(&:id)
+
+        from_date, to_date = calculate_line_item_duration!(
+          date: date,
+          departure_time: trip_stops[leg.boarding_trip_stop_id].departure_time,
+          arrival_time: trip_stops[leg.drop_off_trip_stop_id].arrival_time
+        )
+
+        leg.seat_selections.group_by(&:variant_id).map do |variant_id, seat_selections|
+          line_item = order.line_items.new(
+            product_type: :transit,
+            from_date: from_date,
+            to_date: to_date,
+            variant_id: variant_id,
+            quantity: seat_selections.sum(&:quantity),
+            private_metadata: {
+              direction: leg.direction,
+              trip_id: leg.trip_id.to_s,
+              boarding_trip_stop_id: leg.boarding_trip_stop_id.to_s,
+              drop_off_trip_stop_id: leg.drop_off_trip_stop_id.to_s
+            }
+          )
+
+          build_guests_for!(line_item, seat_selections)
+        end
+      end
+
+      def build_guests_for!(line_item, seat_selections)
+        block_ids = seat_selections.flat_map(&:block_ids)
+
+        if block_ids.any? && block_ids.size != line_item.quantity
+          raise StandardError, "Number of blocks (#{block_ids.size}) does not match quantity (#{line_item.quantity})"
+        end
+
+        Array.new(line_item.quantity) do |index|
+          line_item.guests.new(block_id: block_ids[index])
+        end
+
+        line_item
+      end
+
+      def insert_saved_guests_per_line_items_leg(line_items)
+        line_items.flat_map(&:guests).each_with_index do |guest, index|
+          context.saved_guests ||= []
+          context.saved_guests << SpreeCmCommissioner::SavedGuest.new if context.saved_guests[index].blank?
+
+          guest.saved_guest = context.saved_guests[index]
+        end
+
+        line_items
+      end
+
+      def calculate_line_item_duration!(date:, departure_time:, arrival_time:)
+        raise StandardError, 'Departure or arrival time in trip stop is missing' if departure_time.blank? || arrival_time.blank?
+        raise StandardError, 'Arrival time cannot be before departure time' if arrival_time < departure_time
+
+        trip_duration_in_seconds = arrival_time - departure_time
+
+        # The input `date` is in local time (e.g., 10-10-2022).
+        # Combine it with the departure_time in Rails default timezone so that
+        # the resulting from_date stays on the intended local calendar day when stored in UTC.
+        from_date = Time.zone.local(date.year, date.month, date.day, departure_time.hour, departure_time.min, departure_time.sec)
+        to_date = from_date + trip_duration_in_seconds.seconds
+
+        [from_date, to_date]
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/trip_clone_creator.rb

@@ -0,0 +1,155 @@
+module SpreeCmCommissioner
+  class TripCloneCreator < BaseInteractor
+    delegate :vendor, :params, :original_trip, :places, :current_store, :current_vendor, to: :context
+
+    def call
+      ActiveRecord::Base.transaction do
+        cloned_product = create_cloned_product(original_trip.product)
+        cloned_trip    = create_cloned_trip(original_trip, cloned_product)
+
+        departure_time_from_stops(cloned_trip)
+        calculate_trip_duration(cloned_trip)
+
+        cloned_trip.save!
+        context.cloned_trip = cloned_trip
+        clone_variants(original_trip, cloned_trip)
+      end
+    rescue StandardError => e
+      context.fail!(message: e.message)
+    end
+
+    private
+
+    # Product cloning
+    def create_cloned_product(original_product)
+      return nil unless original_product
+
+      cloned_product = duplicate_product(original_product)
+      assign_vendor_attributes(cloned_product)
+
+      cloned_product.save!
+      cloned_product
+    end
+
+    def duplicate_product(original_product)
+      cloned = original_product.dup
+      %i[variants product_properties classifications option_types].each do |assoc|
+        cloned.public_send("#{assoc}=", [])
+      end
+      cloned
+    end
+
+    def assign_vendor_attributes(cloned_product)
+      cloned_product.vendor_id            = vendor.id
+      cloned_product.store_ids            = [current_store.id]
+      cloned_product.product_type         = :transit
+      cloned_product.status               = :active
+      cloned_product.price = original_trip.product.price if original_trip.product.price.present?
+      cloned_product.option_types = original_trip.product.option_types if original_trip.product.option_types.any?
+
+      return unless params[:product_attributes]
+
+      product_attributes = params[:product_attributes].dup
+      product_attributes[:name] ||= original_trip.product.name.to_s
+      cloned_product.assign_attributes(product_attributes)
+    end
+
+    # Trip cloning
+    def create_cloned_trip(original_trip, cloned_product)
+      cloned_trip = build_cloned_trip(original_trip, cloned_product)
+      cloned_trip.trip_stops = clone_trip_stops(original_trip)
+      cloned_trip
+    end
+
+    def build_cloned_trip(original_trip, cloned_product)
+      cloned = original_trip.dup
+      cloned.product   = cloned_product
+      cloned.vendor_id = vendor.id
+      cloned.assign_attributes(params.except(:product_attributes, :trip_stops_attributes))
+      cloned
+    end
+
+    def clone_trip_stops(original_trip)
+      original_trip.trip_stops.map.with_index do |stop, index|
+        clone_trip_stop(stop, index)
+      end
+    end
+
+    def clone_trip_stop(stop, index)
+      cloned_stop         = stop.dup
+      cloned_stop.id      = nil
+      cloned_stop.trip_id = nil
+
+      apply_trip_stop_params(cloned_stop, index)
+      validate_trip_stop!(cloned_stop)
+
+      cloned_stop
+    end
+
+    def apply_trip_stop_params(cloned_stop, index)
+      stop_params = params.dig(:trip_stops_attributes, index.to_s)
+      return unless stop_params
+
+      cloned_stop.departure_time    = parse_time(stop_params[:departure_time])
+      cloned_stop.arrival_time      = parse_time(stop_params[:arrival_time])
+      cloned_stop.stop_type         = stop_params[:stop_type].presence
+      cloned_stop.location_place_id = stop_params[:location_place_id].presence
+    end
+
+    def parse_time(value)
+      Time.zone.parse(value) if value.present?
+    end
+
+    def validate_trip_stop!(cloned_stop)
+      return if cloned_stop.departure_time.present?
+
+      raise StandardError, "Departure time can't be blank for stop #{cloned_stop.stop_name}"
+    end
+
+    # Clone Variants
+    def clone_variants(original_trip, cloned_trip)
+      original_trip.product.variants.each do |variant|
+        new_variant = cloned_trip.product.variants.create!(
+          price: variant.price,
+          option_value_ids: variant.option_value_ids,
+          sku: ''
+        )
+        clone_variant_blocks(variant, new_variant)
+      end
+    rescue StandardError => e
+      raise StandardError, "Failed to clone variants: #{e.message}"
+    end
+
+    # clone variant_block (seat)
+    def clone_variant_blocks(origin_variant, new_variant)
+      block_data = {
+        block_ids: origin_variant.block_ids || []
+      }
+
+      context = SpreeCmCommissioner::VariantBlockUpdater.call(
+        variant: new_variant,
+        current_store: current_store,
+        data: block_data,
+        stock_location: current_vendor.stock_locations.first
+      )
+
+      raise StandardError, "Failed to update variant blocks: #{context.message}" unless context.success?
+    rescue StandardError => e
+      raise StandardError, "Failed to clone variant blocks: #{e.message}"
+    end
+
+    # Helpers
+    def departure_time_from_stops(trip)
+      first_departure = trip.trip_stops.first&.departure_time
+      trip.departure_time = first_departure if first_departure
+    end
+
+    def calculate_trip_duration(trip)
+      departures = trip.trip_stops.filter_map(&:departure_time)
+      arrivals   = trip.trip_stops.filter_map(&:arrival_time)
+      return if departures.empty? || arrivals.empty?
+
+      trip.duration = (arrivals.max - departures.min).to_i
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/user_fb_token_authenticator.rb

@@ -0,0 +1,37 @@
+module SpreeCmCommissioner
+  class UserFbTokenAuthenticator < BaseInteractor
+    delegate :fb_access_token, :tenant_id, to: :context
+
+    # :fb_access_token, :tenant_id (optional)
+    def call
+      context.fail!(message: 'fb_access_token_missing') unless fb_access_token
+
+      context.user = if checker.user.nil?
+                       register_user
+                     else
+                       checker.user
+                     end
+
+      context.fail!(message: 'account_temporarily_deleted') if context.user.soft_deleted?
+    end
+
+    private
+
+    def checker
+      @checker ||= SpreeCmCommissioner::UserFbTokenChecker.call(
+        fb_access_token: fb_access_token,
+        tenant_id: tenant_id
+      )
+      @checker
+    end
+
+    def register_user
+      register_context = SpreeCmCommissioner::UserRegistrationWithFbToken.call(
+        provider: checker.provider,
+        tenant_id: tenant_id
+      )
+
+      register_context.user
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/user_fb_token_checker.rb

@@ -0,0 +1,20 @@
+module SpreeCmCommissioner
+  class UserFbTokenChecker < BaseInteractor
+    delegate :tenant_id, :fb_access_token, to: :context
+
+    def call
+      fb_data = SpreeCmCommissioner::FetchFacebookUserData.call(fb_access_token: fb_access_token)
+      context.fail!(message: fb_data.message) if fb_data.failure?
+
+      context.provider = fb_data.provider
+
+      identity_checker = SpreeCmCommissioner::UserIdentityChecker.call(
+        identity_type: context.provider[:identity_type],
+        sub: context.provider[:sub],
+        tenant_id: tenant_id
+      )
+
+      context.user = identity_checker.success? ? identity_checker.user : nil
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/user_identity_checker.rb

@@ -1,28 +1,28 @@
 module SpreeCmCommissioner
   class UserIdentityChecker < BaseInteractor
+    delegate :identity_type, :sub, :tenant_id, to: :context
+
     # expects:
     #   context.identity_type
     #   context.sub
     #   context.tenant_id (optional)
-
     def call
       load_user
 
       return unless context.user.nil?
 
-      error_message = I18n.t('user_identity_provider.not_found', identity_type: context.identity_type)
+      error_message = I18n.t('user_identity_provider.not_found', identity_type: identity_type)
       context.fail!(message: error_message)
     end
 
     def load_user
-      return if context.sub.blank? || context.identity_type.blank?
+      return if sub.blank? || identity_type.blank?
 
-      user_identity_provider = UserIdentityProvider.joins(:user)
-                                                   .where(identity_type: context.identity_type, sub: context.sub)
-                                                   .where(spree_users: { tenant_id: context.tenant_id })
-                                                   .first
+      user_identity_providers = UserIdentityProvider.joins(:user)
+                                                    .where(identity_type: identity_type, sub: sub)
+                                                    .where(spree_users: { tenant_id: tenant_id })
 
-      context.user = user_identity_provider&.user
+      context.user = user_identity_providers.first&.user
     end
   end
 end