spree_cm_commissioner 2.0.0.pre.pre → 2.0.1.pre.pre1

data/app/models/spree_cm_commissioner/pin_code.rb

@@ -2,7 +2,7 @@ module SpreeCmCommissioner
   class PinCode < SpreeCmCommissioner::Base
     has_secure_token
 
-    enum contact_type: { 'phone_number' => 0, 'email' => 1 }
+    enum contact_type: { 'phone_number' => 0, 'email' => 1, 'telegram' => 2 }
 
     validates :code, length: { maximum: 6 }
     validates :contact, presence: true
@@ -130,7 +130,8 @@ module SpreeCmCommissioner
         'SpreeCmCommissioner::PinCodeMobileConfirm' => I18n.t('pincode.readable_type.confirmation_code'),
         'SpreeCmCommissioner::PinCodeUpdateUserLogin' => I18n.t('pincode.readable_type.update_user_login'),
         'SpreeCmCommissioner::PinCodeEmailConfirm' => I18n.t('pincode.readable_type.confirmation_code'),
-        'SpreeCmCommissioner::OtpCode' => I18n.t('pincode.readable_type.otp_code')
+        'SpreeCmCommissioner::OtpCode' => I18n.t('pincode.readable_type.otp_code'),
+        'SpreeCmCommissioner::PinCodeTelegram' => I18n.t('pincode.readable_type.telegram_verification')
       }
     end
 

data/app/models/spree_cm_commissioner/pin_code_telegram.rb

@@ -0,0 +1,28 @@
+module SpreeCmCommissioner
+  class PinCodeTelegram < PinCode
+    before_validation :set_telegram_attrs, on: :create
+    validates :contact, presence: true, numericality: { only_integer: true }, if: :telegram?
+
+    belongs_to :vendor, class_name: 'Spree::Vendor', foreign_key: 'contact', primary_key: 'id'
+
+    def telegram?
+      true
+    end
+
+    def expires_in_seconds
+      5 * 60
+    end
+
+    def expired?
+      expired_at < Time.zone.now
+    end
+
+    private
+
+    def set_telegram_attrs
+      self.contact_type = :telegram
+      self.type = 'SpreeCmCommissioner::PinCodeTelegram'
+      self.expired_at = Time.zone.now + expires_in_seconds unless expired_at
+    end
+  end
+end

data/app/models/spree_cm_commissioner/place.rb

@@ -1,5 +1,7 @@
+require_dependency 'spree_cm_commissioner'
+
 module SpreeCmCommissioner
-  class Place < Base
+  class Place < ApplicationRecord
     acts_as_nested_set
 
     validates :reference, presence: true, if: :validate_reference?

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -6,6 +6,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::KycBitwise
       base.include SpreeCmCommissioner::Metafield
       base.include SpreeCmCommissioner::TenantUpdatable
+      base.include SpreeCmCommissioner::RouteType
 
       base.has_many :variant_kind_option_types, -> { where(kind: :variant).order(:position) },
                     through: :product_option_types, source: :option_type
@@ -32,7 +33,6 @@ module SpreeCmCommissioner
       base.has_one :google_wallet, class_name: 'SpreeCmCommissioner::GoogleWallet', dependent: :destroy
 
       base.has_many :complete_line_items, through: :classifications, source: :line_items
-      base.has_many :inventory_items, through: :variants
       base.has_many :guests, through: :line_items
 
       base.has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
@@ -64,11 +64,12 @@ module SpreeCmCommissioner
       base.before_validation :set_event_id
 
       base.validate :validate_event_taxons, if: -> { taxons.event.present? }
+
       base.validate :validate_product_date, if: -> { available_on.present? && discontinue_on.present? }
-      base.validate :product_type_unchanged, on: :update
+
       base.validates :commission_rate, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }, allow_nil: true
 
-      base.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status vendor_id short_name]
+      base.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status vendor_id short_name route_type]
 
       base.after_update :update_variants_vendor_id, if: :saved_change_to_vendor_id?
       base.after_update :sync_event_id_to_children, if: :saved_change_to_event_id?
@@ -113,13 +114,6 @@ module SpreeCmCommissioner
 
       errors.add(:discontinue_on, 'must be after the available on date')
     end
-
-    def product_type_unchanged
-      return if product_type_was.nil?
-      return unless product_type_changed?
-
-      errors.add(:product_type, 'cannot be changed once set')
-    end
   end
 end
 

data/app/models/spree_cm_commissioner/promotion_category_decorator.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  module PromotionCategoryDecorator
+    def self.prepended(base)
+      base.belongs_to :vendor, class_name: 'Spree::Vendor', optional: true
+    end
+  end
+end
+
+unless Spree::PromotionCategory.included_modules.include?(SpreeCmCommissioner::PromotionCategoryDecorator)
+  Spree::PromotionCategory.prepend(SpreeCmCommissioner::PromotionCategoryDecorator)
+end

data/app/models/spree_cm_commissioner/service_calendar.rb

@@ -1,3 +1,5 @@
+require_dependency 'spree_cm_commissioner'
+
 module SpreeCmCommissioner
   class ServiceCalendar < SpreeCmCommissioner::Base
     # exception_rules = [

data/app/models/spree_cm_commissioner/state_decorator.rb

@@ -3,6 +3,7 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.whitelisted_ransackable_attributes |= %w[name abbr country_id]
       base.has_many :vendors, foreign_key: 'default_state_id', class_name: 'Spree::Vendor', inverse_of: :default_state, dependent: :nullify
+      base.has_many :stops, class_name: 'SpreeCmCommissioner::Place'
 
       def update_total_inventory
         update(total_inventory: vendors.pluck(:total_inventory).compact.sum)

data/app/models/spree_cm_commissioner/stock/availability_checker.rb

@@ -1,48 +1,47 @@
 module SpreeCmCommissioner
   module Stock
     class AvailabilityChecker
-      attr_reader :variant, :options, :error_message
+      attr_reader :variant, :error_message
 
-      def initialize(variant, options = {})
+      def initialize(variant)
         @variant = variant
-        @options = options
         @error_message = nil
       end
 
-      def can_supply?(quantity = 1)
+      def can_supply?(quantity = 1, options = {})
         return false unless variant.available?
         return true unless variant.should_track_inventory?
         return true if variant.backorderable?
         return true if variant.need_confirmation?
 
-        variant_available?(quantity)
-      end
-
-      def variant_available?(quantity = 1)
-        return false if cached_inventory_items.empty?
-
-        cached_inventory_items.all? do |cached_inventory_item|
-          cached_inventory_item.active? && cached_inventory_item.quantity_available >= quantity
-        end
-      end
-
-      def cached_inventory_items
-        return @cached_inventory_items if defined?(@cached_inventory_items)
+        # when delivery required, shipment will dynamically add / remove unit from stock item.
+        # so we can directly check can_supply with stock items directly.
+        return variant.stock_items.sum(:count_on_hand) >= quantity if variant.delivery_required?
 
         if variant.permanent_stock?
-          return [] if options[:from_date].blank? || options[:to_date].blank?
-
-          dates = options[:from_date].to_date..options[:to_date].to_date
-          @cached_inventory_items = builder_klass.new(variant_id: variant.id, dates: dates).call
-          @cached_inventory_items = [] if @cached_inventory_items.size != dates.count
-          @cached_inventory_items
+          permanent_stock_variant_available?(quantity, options)
         else
-          @cached_inventory_items = builder_klass.new(variant_id: variant.id).call
+          variant_available?(quantity, options)
         end
       end
 
-      def builder_klass
-        ::SpreeCmCommissioner::RedisStock::VariantCachedInventoryItemsBuilder
+      def variant_available?(quantity = 1, options = {})
+        query = SpreeCmCommissioner::VariantAvailability::NonPermanentStockQuery.new(
+          variant: variant,
+          except_line_item_id: options[:except_line_item_id]
+        )
+        result = query.available?(quantity)
+        @error_message = query.error_message unless result
+        result
+      end
+
+      def permanent_stock_variant_available?(quantity = 1, options = {})
+        SpreeCmCommissioner::VariantAvailability::PermanentStockQuery.new(
+          variant: variant,
+          from_date: options[:from_date].to_date,
+          to_date: options[:to_date].to_date,
+          except_line_item_id: options[:except_line_item_id]
+        ).available?(quantity)
       end
     end
   end

data/app/models/spree_cm_commissioner/stock/availability_validator_decorator.rb

@@ -3,8 +3,7 @@ module SpreeCmCommissioner
     module AvailabilityValidatorDecorator
       # override
       def item_available?(line_item, quantity)
-        SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item)
-                                                               .can_supply?(quantity)
+        SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item).can_supply?(quantity)
       end
     end
   end

data/app/models/spree_cm_commissioner/stock/line_item_availability_checker.rb

@@ -8,14 +8,14 @@ module SpreeCmCommissioner
       end
 
       def can_supply?(quantity)
-        ::SpreeCmCommissioner::Stock::AvailabilityChecker.new(line_item.variant, options)
-                                                         .can_supply?(quantity)
+        AvailabilityChecker.new(line_item.variant).can_supply?(quantity, options)
       end
 
       def options
         {
           from_date: line_item.from_date,
-          to_date: line_item.to_date
+          to_date: line_item.to_date,
+          except_line_item_id: line_item.id
         }
       end
     end

data/app/models/spree_cm_commissioner/stock_item_decorator.rb

@@ -3,28 +3,11 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.has_one :vendor, through: :variant
       base.after_save :update_vendor_total_inventory, if: :saved_change_to_count_on_hand?
-
-      base.after_commit :create_inventory_items, on: :create
-      base.after_commit :adjust_inventory_items_async, on: :destroy
     end
 
     def update_vendor_total_inventory
       SpreeCmCommissioner::VendorJob.perform_later(vendor.id) if vendor.present?
     end
-
-    private
-
-    def create_inventory_items
-      SpreeCmCommissioner::Stock::InventoryItemsGeneratorJob.perform_later(variant_id: variant.id)
-    end
-
-    # When admin delete stock item, it will deduct stock from inventory item
-    def adjust_inventory_items_async
-      params = { variant_id: variant.id, quantity: -count_on_hand }
-      CmAppLogger.log(label: "#{self.class.name}#adjust_inventory_items_async", data: params) do
-        SpreeCmCommissioner::Stock::InventoryItemsAdjusterJob.perform_later(**params)
-      end
-    end
   end
 end
 

data/app/models/spree_cm_commissioner/stop.rb

@@ -0,0 +1,23 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class Stop < SpreeCmCommissioner::Place
+    belongs_to :branch, class_name: 'SpreeCmCommissioner::Branch'
+    belongs_to :state,  class_name: 'Spree::State', optional: true
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+
+    after_save :add_to_option_value
+
+    def validate_reference?
+      false
+    end
+
+    def add_to_option_value
+      origin = Spree::OptionType.find_by(attr_type: 'origin')&.id
+      destination = Spree::OptionType.find_by(attr_type: 'destination')&.id
+
+      Spree::OptionValue.create(option_type_id: origin, name: name, presentation: id)
+      Spree::OptionValue.create(option_type_id: destination, name: name, presentation: id)
+    end
+  end
+end

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -2,7 +2,9 @@ module SpreeCmCommissioner
   module TaxonDecorator
     def self.prepended(base) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       base.include SpreeCmCommissioner::TaxonKind
+      base.include SpreeCmCommissioner::Transit::TaxonBitwise
       base.include SpreeCmCommissioner::ParticipationTypeBitwise
+      base.include SpreeCmCommissioner::EventCheckInFlowable
 
       base.preference :background_color, :string
       base.preference :foreground_color, :string
@@ -55,14 +57,16 @@ module SpreeCmCommissioner
       base.has_many :crew_invites, class_name: 'SpreeCmCommissioner::CrewInvite', dependent: :destroy
       base.has_many :invite_user_events, through: :user_events, class_name: 'SpreeCmCommissioner::InviteUserEvent'
 
+      base.has_many :crew_invite_links, class_name: 'SpreeCmCommissioner::CrewInviteLink', dependent: :destroy
+
       base.has_many :invite_guests, class_name: 'SpreeCmCommissioner::InviteGuest', foreign_key: :event_id
 
       base.has_many :line_items, through: :products
       base.has_many :event_line_items, class_name: 'Spree::LineItem', foreign_key: :event_id
       base.has_many :event_products, class_name: 'Spree::Product', foreign_key: :event_id
 
-      base.has_many :event_blazer_queries, class_name: 'SpreeCmCommissioner::TaxonBlazerQuery'
-      base.has_many :blazer_queries, through: :event_blazer_queries, class_name: 'Blazer::Query'
+      base.has_many :event_blazer_queries, as: :queryable, class_name: 'SpreeCmCommissioner::BlazerQueryable'
+      base.has_many :blazer_queries, through: :event_blazer_queries, source: :blazer_query, class_name: 'Blazer::Query'
 
       base.has_many :taxon_option_types, class_name: 'SpreeCmCommissioner::TaxonOptionType'
       base.has_many :taxon_option_values, class_name: 'SpreeCmCommissioner::TaxonOptionValue'

data/app/models/spree_cm_commissioner/taxonomy_decorator.rb

@@ -8,6 +8,12 @@ module SpreeCmCommissioner
           Spree::Taxonomy.find_or_create_by(name: 'Businesses', kind: 'category', store: Spree::Store.default)
         end
       end
+
+      def base.place
+        ActiveRecord::Base.connected_to(role: :writing) do
+          Spree::Taxonomy.find_or_create_by(name: 'Place', kind: 'transit', store: Spree::Store.default)
+        end
+      end
     end
   end
 end

data/app/models/spree_cm_commissioner/telegram_chat.rb

@@ -0,0 +1,6 @@
+module SpreeCmCommissioner
+  class TelegramChat < Base
+    belongs_to :vendor, class_name: 'Spree::Vendor'
+    validates :chat_id, presence: true, uniqueness: true
+  end
+end

data/app/models/spree_cm_commissioner/trip.rb

@@ -1,7 +1,6 @@
+require_dependency 'spree_cm_commissioner'
 module SpreeCmCommissioner
-  class Trip < Base
-    include SpreeCmCommissioner::RouteType
-
+  class Trip < SpreeCmCommissioner::Base
     attr_accessor :hours, :minutes, :seconds
 
     before_validation :convert_duration_to_seconds
@@ -11,29 +10,28 @@ module SpreeCmCommissioner
     belongs_to :origin, class_name: 'SpreeCmCommissioner::Place', optional: true
     belongs_to :destination, class_name: 'SpreeCmCommissioner::Place', optional: true
 
+    has_many :trip_blazer_queries, as: :queryable, class_name: 'SpreeCmCommissioner::BlazerQueryable'
+    has_many :blazer_queries, through: :trip_blazer_queries, source: :blazer_query, class_name: 'Blazer::Query'
+
     has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy
     has_many :variants, through: :product
     has_many :inventory_items, through: :variants
+    belongs_to :variant, class_name: 'Spree::Variant'
+
+    belongs_to :route, class_name: 'Spree::Product'
+    belongs_to :vehicle, class_name: 'SpreeCmCommissioner::Vehicle'
+    validates :departure_time, presence: true
 
     validates :departure_time, presence: true
     validates :duration, numericality: { greater_than: 0 }
     validate :origin_and_destination_cannot_be_the_same
 
-    accepts_nested_attributes_for :trip_stops, allow_destroy: true
-
-    after_create :create_trip_stops
-
     def convert_duration_to_seconds
       return if hours.blank? && minutes.blank? && seconds.blank?
 
       self.duration = (hours.to_i * 3600) + (minutes.to_i * 60) + seconds.to_i
     end
 
-    def create_trip_stops
-      trip_stops.find_or_create_by(stop_type: :boarding, stop_id: origin_id)
-      trip_stops.find_or_create_by(stop_type: :drop_off, stop_id: destination_id)
-    end
-
     def duration_in_hms
       return { hours: 0, minutes: 0, seconds: 0 } if duration.nil?
 

data/app/models/spree_cm_commissioner/trip_connection.rb

@@ -1,7 +1,7 @@
 module SpreeCmCommissioner
-  class TripConnection < Base
-    belongs_to :from_trip, class_name: 'SpreeCmCommissioner::Trip'
-    belongs_to :to_trip, class_name: 'SpreeCmCommissioner::Trip'
+  class TripConnection < ApplicationRecord
+    belongs_to :from_trip, class_name: 'Spree::Variant'
+    belongs_to :to_trip, class_name: 'Spree::Variant'
 
     validate :both_trip_cannot_be_the_same
     before_validation :calculate_connection_time_minutes
@@ -12,8 +12,8 @@ module SpreeCmCommissioner
     def calculate_connection_time_minutes
       return if from_trip.nil? || to_trip.nil?
 
-      arrival_seconds   = from_trip.arrival_time.seconds_since_midnight
-      departure_seconds = to_trip.departure_time.seconds_since_midnight
+      arrival_seconds   = from_trip.trip.arrival_time.seconds_since_midnight
+      departure_seconds = to_trip.trip.departure_time.seconds_since_midnight
 
       layover_seconds = departure_seconds - arrival_seconds
       layover_seconds += 86_400 if layover_seconds.negative?

data/app/models/spree_cm_commissioner/trip_stop.rb

@@ -1,9 +1,10 @@
+require_dependency 'spree_cm_commissioner'
 module SpreeCmCommissioner
-  class TripStop < Base
+  class TripStop < SpreeCmCommissioner::Base
     acts_as_list column: :sequence, scope: :trip_id
     enum :stop_type, { boarding: 0, drop_off: 1 }
 
-    belongs_to :trip, class_name: 'SpreeCmCommissioner::Trip'
+    belongs_to :trip, class_name: 'Spree::Variant'
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
     before_validation :set_stop_name

data/app/models/spree_cm_commissioner/user_identity_provider.rb

@@ -3,15 +3,17 @@ module SpreeCmCommissioner
     enum identity_type: { :google => 0, :apple => 1, :facebook => 2, :telegram => 3, :vattanac_bank => 4 }
 
     belongs_to :user, class_name: Spree.user_class.to_s, optional: false
+    has_one :tenant, through: :user
 
-    validates :sub, presence: true
-    validates :sub, uniqueness: { scope: :identity_type }
+    has_many :user_identity_provider_telegram_bots
+    has_many :telegram_bots, through: :user_identity_provider_telegram_bots
 
+    validates :sub, presence: true
     validates :identity_type, presence: true
     validates :identity_type, uniqueness: { scope: :user_id }
 
-    has_many :user_identity_provider_telegram_bots
-    has_many :telegram_bots, through: :user_identity_provider_telegram_bots
+    # custom validation to ensure that the sub is unique per identity_type and spree_users.tenant
+    validate :unique_sub_per_identity_type_and_tenant
 
     # sub is a telegram uid, which telegram considered a chatID if
     # user have /started with bot.
@@ -20,5 +22,25 @@ module SpreeCmCommissioner
 
       nil
     end
+
+    private
+
+    def unique_sub_per_identity_type_and_tenant
+      return if user.nil? || sub.blank? || identity_type.blank?
+
+      tenant_id = user.tenant_id
+
+      # Check for duplicates in the same tenant
+      scope = self.class
+                  .joins(:user)
+                  .where(sub: sub, identity_type: identity_type)
+                  .where(spree_users: { tenant_id: tenant_id })
+
+      scope = scope.where.not(id: id) if persisted?
+
+      return unless scope.exists?
+
+      errors.add(:sub, 'must be unique per identity_type and tenant')
+    end
   end
 end

data/app/models/spree_cm_commissioner/user_taxon.rb

@@ -2,5 +2,6 @@ module SpreeCmCommissioner
   class UserTaxon < Base
     belongs_to :user, class_name: Spree.user_class.to_s, optional: false
     belongs_to :taxon, class_name: 'Spree::Taxon', optional: false
+    has_many :invite_user_taxons, class_name: 'SpreeCmCommissioner::InviteUserTaxon', dependent: :destroy
   end
 end

data/app/models/spree_cm_commissioner/variant_decorator.rb

@@ -1,7 +1,6 @@
 module SpreeCmCommissioner
   module VariantDecorator
-    def self.prepended(base) # rubocop:disable Metrics/AbcSize
-      base.include SpreeCmCommissioner::ProductType
+    def self.prepended(base)
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::VariantOptionsConcern
       base.include SpreeCmCommissioner::KycBitwise
@@ -21,21 +20,24 @@ module SpreeCmCommissioner
       base.has_many :video_on_demands, class_name: 'SpreeCmCommissioner::VideoOnDemand', dependent: :destroy
       base.has_many :complete_line_items, -> { complete }, class_name: 'Spree::LineItem'
 
-      base.has_many :variant_blocks, class_name: 'SpreeCmCommissioner::VariantBlock', dependent: :destroy
-      base.has_many :blocks, class_name: 'SpreeCmCommissioner::Block', through: :variant_blocks
-
       base.has_many :variant_guest_card_class, class_name: 'SpreeCmCommissioner::VariantGuestCardClass'
       base.has_many :guest_card_classes, class_name: 'SpreeCmCommissioner::GuestCardClass', through: :variant_guest_card_class
 
-      base.has_many :inventory_items, class_name: 'SpreeCmCommissioner::InventoryItem'
-
       base.scope :subscribable, -> { active.joins(:product).where(product: { subscribable: true, status: :active }) }
-      base.scope :with_permanent_stock, -> { where(product_type: base::PERMANENT_STOCK_PRODUCT_TYPES) }
-      base.scope :with_non_permanent_stock, -> { where.not(product_type: base::PERMANENT_STOCK_PRODUCT_TYPES) }
-
+      base.has_one :trip,
+                   class_name: 'SpreeCmCommissioner::Trip'
+      base.has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy, foreign_key: :trip_id
       base.accepts_nested_attributes_for :option_values
+      base.after_commit :sync_trip, if: :transit?
+      base.accepts_nested_attributes_for :trip_stops, allow_destroy: true
+      base.after_commit :create_trip_stops, if: :transit?
+    end
+
+    def create_trip_stops
+      return if is_master?
 
-      base.before_save -> { self.product_type = product.product_type }, if: -> { product_type.nil? }
+      trip_stops.find_or_create_by(stop_type: :boarding, stop_id: options.origin)
+      trip_stops.find_or_create_by(stop_type: :drop_off, stop_id: options.destination)
     end
 
     def delivery_required?
@@ -51,20 +53,8 @@ module SpreeCmCommissioner
       super || product.discontinued?
     end
 
-    def default_inventory_item_exist?
-      inventory_items.exists?(inventory_date: nil)
-    end
-
-    def create_default_non_permanent_inventory_item!(quantity_available: nil, max_capacity: nil)
-      return if product_type.blank? # handle in case product not exist for variant.
-      return unless should_track_inventory?
-      return if default_inventory_item_exist?
-
-      inventory_items.create!(
-        product_type: product_type,
-        quantity_available: [0, quantity_available || total_on_hand].max,
-        max_capacity: [0, max_capacity || total_on_hand].max
-      )
+    def permanent_stock?
+      accommodation?
     end
 
     # override
@@ -82,25 +72,30 @@ module SpreeCmCommissioner
       "#{display_sku} - #{display_price}"
     end
 
+    def transit?
+      product.product_type == 'transit'
+    end
+
     # override
-    def in_stock?(options = {})
-      SpreeCmCommissioner::Stock::AvailabilityChecker.new(self, options).can_supply?
+    def in_stock?
+      available_quantity.positive?
     end
 
-    def price_for_date(currency:, date:)
-      currency = currency.upcase
+    private
 
-      prices.joins(:inventory_item)
-            .find_by(
-              currency: currency,
-              inventory_item: { inventory_date: date }
-            )
+    def total_purchases
+      Spree::LineItem.complete.where(variant_id: id).sum(:quantity).to_i
     end
 
-    private
+    def available_quantity
+      stock_count = stock_items.sum(&:count_on_hand)
+      return stock_count if delivery_required?
+
+      stock_count - total_purchases
+    end
 
     def update_vendor_price
-      return unless vendor.present? && product_type == vendor&.primary_product_type
+      return unless vendor.present? && product&.product_type == vendor&.primary_product_type
 
       vendor.update(min_price: price) if vendor.min_price.nil? || price < vendor.min_price
       vendor.update(max_price: price) if vendor.max_price.nil? || price > vendor.max_price
@@ -124,6 +119,22 @@ module SpreeCmCommissioner
         end
       end
     end
+
+    def sync_trip
+      return unless product.product_type == 'transit'
+
+      trip = SpreeCmCommissioner::Trip.find_or_initialize_by(variant_id: id)
+
+      trip.assign_attributes(
+        product_id: product_id,
+        origin_id: options.origin,
+        destination_id: options.destination,
+        departure_time: options.departure_time,
+        duration: options.total_duration_in_seconds,
+        vehicle_id: options.vehicle
+      )
+      trip.save
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/variant_options.rb

@@ -143,5 +143,28 @@ module SpreeCmCommissioner
     def number_of_guests
       number_of_adults + number_of_kids
     end
+
+    def origin
+      @origin ||= option_value_name_for(option_type_name: 'origin')&.to_i
+    end
+
+    def destination
+      @destination ||= option_value_name_for(option_type_name: 'destination')&.to_i
+    end
+
+    def vehicle
+      @vehicle ||= option_value_name_for(option_type_name: 'vehicle')&.to_i
+    end
+
+    def allow_seat_selection
+      @allow_seat_selection ||= option_value_name_for(option_type_name: 'allow-seat-selection')&.to_i
+    end
+
+    def departure_time
+      @departure_time ||= begin
+        time = option_value_name_for(option_type_name: 'departure-time')
+        Time.zone.parse(time) if time.present?
+      end
+    end
   end
 end