spree_cm_commissioner 1.9.2 → 1.10.0.pre.pre

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

@@ -0,0 +1,71 @@
+module SpreeCmCommissioner
+  module Stock
+    class PermanentInventoryItemsGenerator < BaseInteractor
+      delegate :variant_ids, to: :context
+
+      def variants_per_batch = 1000
+
+      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 + variant.pre_inventory_days
+
+        (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).includes(:product)
+        scope = scope.where(id: variant_ids) if variant_ids.present?
+        scope
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/vattanac_bank_initiator.rb

@@ -25,10 +25,8 @@ module SpreeCmCommissioner
     end
 
     def verify_signature
-      public_key = ENV['VATTANAC_PUBLIC_KEY'].presence || Rails.application.credentials.vattanac.public_key
-
       rsa_service = SpreeCmCommissioner::RsaService.new(
-        public_key: public_key
+        public_key: vattanac_public_key
       )
 
       return if rsa_service.verify(context.encrypted_data, context.signature)
@@ -37,8 +35,6 @@ module SpreeCmCommissioner
     end
 
     def decrypt_payload
-      aes_key = ENV['VATTANAC_AES_SECRET_KEY'].presence || Rails.application.credentials.vattanac.aes_secret_key
-
       context.fail!(message: 'Invalid AES key length', status: :unprocessable_entity) unless aes_key
 
       begin
@@ -99,18 +95,41 @@ module SpreeCmCommissioner
 
     def construct_data
       user = context.user
-      context.data = {
+
+      raw_data = {
         sessionId: session_id,
         name: user.full_name,
         phone: user.phone_number,
         email: user.email,
         webUrl: "#{Spree::Store.default.formatted_url}/vattanac_bank_web_app?session_id=#{session_id}"
       }
+
+      json_data = raw_data.to_json
+
+      encrypted_data = SpreeCmCommissioner::AesEncryptionService.encrypt(json_data, aes_key)
+
+      rsa_service = SpreeCmCommissioner::RsaService.new(private_key: bookmeplus_private_key)
+
+      signed_data = rsa_service.sign(encrypted_data)
+
+      context.data = signed_data
     end
 
     def session_id
       payload = { user_id: context.user.id }
       SpreeCmCommissioner::UserSessionJwtToken.encode(payload, context.user.reload.secure_token)
     end
+
+    def aes_key
+      ENV['VATTANAC_AES_SECRET_KEY'].presence || Rails.application.credentials.vattanac.aes_secret_key
+    end
+
+    def bookmeplus_private_key
+      ENV['BOOKMEPLUS_PRIVATE_KEY'].presence || Rails.application.credentials.bookmeplus.private_key
+    end
+
+    def vattanac_public_key
+      ENV['VATTANAC_PUBLIC_KEY'].presence || Rails.application.credentials.vattanac.public_key
+    end
   end
 end

data/app/jobs/spree_cm_commissioner/firebase_email_fetcher_job.rb

@@ -0,0 +1,9 @@
+module SpreeCmCommissioner
+  class FirebaseEmailFetcherJob < ApplicationJob
+    queue_as :default
+
+    def perform
+      SpreeCmCommissioner::FirebaseEmailFetcherCronExecutor.call
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/inventory_item_syncer_job.rb

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

@@ -0,0 +1,9 @@
+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_state_machine.rb

@@ -13,10 +13,13 @@ module SpreeCmCommissioner
       state_machine.after_transition to: :complete, do: :notify_order_complete_telegram_notification_to_user, unless: :subscription?
       state_machine.after_transition to: :complete, do: :send_order_complete_telegram_alert_to_vendors, unless: :need_confirmation?
       state_machine.after_transition to: :complete, do: :send_order_complete_telegram_alert_to_store, unless: :need_confirmation?
+      state_machine.around_transition to: :complete, do: :handle_unstock_in_redis
 
       state_machine.after_transition to: :resumed, do: :precalculate_conversion
+      state_machine.around_transition to: :resumed, do: :handle_unstock_in_redis
 
       state_machine.after_transition to: :canceled, do: :precalculate_conversion
+      state_machine.after_transition to: :canceled, do: :restock_inventory_in_redis!
 
       scope :accepted, -> { where(request_state: 'accepted') }
 
@@ -66,6 +69,29 @@ module SpreeCmCommissioner
       end
     end
 
+    def handle_unstock_in_redis
+      ActiveRecord::Base.transaction do
+        yield # Equal to block.call
+
+        # After the transition is complete, the following code will execute first before proceeding to other `after_transition` callbacks.
+        # This ensures that if `unstock_inventory_in_redis!` fails, the state will be rolled back,
+        # and neither the `finalize!` method nor any notifications will be triggered.
+        # The payment will be reversed in vPago gem, and `Spree::Checkout::Complete` will be called, which checks `order.reload.complete?`.
+        # This is critical because if the order state is complete, the payment will be marked as paid.
+        CmAppLogger.log(label: 'order_state_machine_before_unstock', data: { order_id: id, state: state })
+        unstock_inventory_in_redis!
+        # We rollback only order state, and we keep payment state as it is.
+        # We implement payment in vPago gem, and it will be reversed in the gem.
+        # Some bank has api for refund, but some don't have the api to refund yet. So we keep the payment state as it is and refund manually.
+        CmAppLogger.log(label: 'order_state_machine_after_unstock', data: { order_id: id, state: state })
+      end
+    rescue StandardError => e
+      CmAppLogger.log(label: 'order_state_machine',
+                      data: { order_id: id, error: e.message, type: e.class.name, backtrace: e.backtrace.first(5).join("\n") }
+                     )
+      raise e
+    end
+
     def generate_bib_number
       line_items.find_each(&:generate_remaining_guests)
 

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

@@ -6,10 +6,20 @@ module SpreeCmCommissioner
     extend ActiveSupport::Concern
 
     PRODUCT_TYPES = %i[accommodation service ecommerce transit].freeze
+    PERMANENT_STOCK_PRODUCT_TYPES = %w[accommodation service transit].freeze
+    PRE_INVENTORY_DAYS = { 'transit' => 90, 'accommodation' => 365, 'service' => 30 }.freeze
 
     included do
       enum product_type: PRODUCT_TYPES if table_exists? && column_names.include?('product_type')
       enum primary_product_type: PRODUCT_TYPES if table_exists? && column_names.include?('primary_product_type')
     end
+
+    def permanent_stock?
+      PERMANENT_STOCK_PRODUCT_TYPES.include?(product_type)
+    end
+
+    def pre_inventory_days
+      PRE_INVENTORY_DAYS[product_type]
+    end
   end
 end

data/app/models/spree_cm_commissioner/inventory.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  class Inventory
+    include ActiveModel::Model
+
+    attr_accessor :variant_id, :inventory_date, :quantity_available, :max_capacity, :product_type
+
+    validates :variant_id, presence: true
+    validates :quantity_available, numericality: { only_integer: true, greater_than_or_equal_to: 0 }, allow_nil: true
+    validates :max_capacity, numericality: { only_integer: true, greater_than_or_equal_to: 0 }, allow_nil: true
+  end
+end

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -0,0 +1,37 @@
+module SpreeCmCommissioner
+  class InventoryItem < ApplicationRecord
+    include SpreeCmCommissioner::ProductType
+
+    # Association
+    belongs_to :variant, class_name: 'Spree::Variant'
+
+    # Validation
+    validates :quantity_available, numericality: { greater_than_or_equal_to: 0 }
+    validates :max_capacity, numericality: { greater_than_or_equal_to: 0 } # Originally inventory of each variant.
+    validates :inventory_date, presence: true, if: -> { permanent_stock? }
+    validates :variant_id, uniqueness: { scope: :inventory_date, message: -> (object, _data) { "The variant is taken on #{object.inventory_date}" } }
+
+    # Scope
+    scope :for_product, -> (type) { where(product_type: type) }
+    scope :active, -> { where(inventory_date: nil).or(where('inventory_date >= ?', Time.zone.today)) }
+
+    def adjust_quantity!(quantity)
+      with_lock do
+        self.max_capacity = max_capacity + quantity
+        self.quantity_available = quantity_available + quantity
+
+        save!
+      end
+    end
+
+    def active?
+      inventory_date.nil? || inventory_date >= Time.zone.today
+    end
+
+    def redis_expired_in
+      expired_in = 31_536_000 # 1 year for normal stock
+      expired_in = Time.parse(inventory_date.to_s).end_of_day.to_i - Time.zone.now.to_i if inventory_date.present?
+      [expired_in, 0].max
+    end
+  end
+end

data/app/models/spree_cm_commissioner/invite_user_taxon.rb

@@ -2,6 +2,7 @@ module SpreeCmCommissioner
   class InviteUserTaxon < SpreeCmCommissioner::Base
     belongs_to :user_taxon, class_name: 'SpreeCmCommissioner::UserTaxon'
     belongs_to :invite, class_name: 'SpreeCmCommissioner::Invite'
+    has_one :inviter, class_name: 'Spree::User', through: :invite
     after_create :send_crew_invite_email
 
     def send_crew_invite_email

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -9,6 +9,7 @@ module SpreeCmCommissioner
       base.has_one :google_wallet, class_name: 'SpreeCmCommissioner::GoogleWallet', through: :product
 
       base.has_many :option_types, through: :product
+      base.has_many :inventory_items, through: :variant
       base.has_many :taxons, class_name: 'Spree::Taxon', through: :product
       base.has_many :guests, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
       base.has_many :pending_guests, pending_guests_query, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -58,6 +58,13 @@ module SpreeCmCommissioner
       end
     end
 
+    # override
+    # spree use this method to check stock availability & consider whether :order can continue to next state.
+    def insufficient_stock_lines
+      checker = SpreeCmCommissioner::Stock::OrderAvailabilityChecker.new(self)
+      checker.insufficient_stock_lines
+    end
+
     def ticket_seller_user?
       return false if user.nil?
 
@@ -194,6 +201,14 @@ module SpreeCmCommissioner
 
     private
 
+    def unstock_inventory_in_redis!
+      SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).unstock!
+    end
+
+    def restock_inventory_in_redis!
+      SpreeCmCommissioner::RedisStock::InventoryUpdater.new(line_item_ids).restock!
+    end
+
     # override :spree_api
     def webhook_payload_body
       resource_serializer.new(

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -33,6 +33,7 @@ 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 :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
       base.has_many :places, through: :product_places
@@ -57,6 +58,9 @@ module SpreeCmCommissioner
       base.scope :subscribable, -> { where(subscribable: 1) }
 
       base.validate :validate_event_taxons, if: -> { taxons.event.present? }
+
+      base.validate :validate_product_date, if: -> { available_on.present? && discontinue_on.present? }
+
       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 route_type]
@@ -93,6 +97,12 @@ module SpreeCmCommissioner
       errors.add(:taxons, 'Event Taxon can\'t not be more than 1') if taxons.event.size > 1
       errors.add(:taxons, 'Must add event date to taxon') if taxons.event.first.from_date.nil? || taxons.event.first.to_date.nil?
     end
+
+    def validate_product_date
+      return unless discontinue_on < available_on
+
+      errors.add(:discontinue_on, 'must be after the available on date')
+    end
   end
 end
 

data/app/models/spree_cm_commissioner/prototype_decorator.rb

@@ -1,6 +1,9 @@
 module SpreeCmCommissioner
   module PrototypeDecorator
     def self.prepended(base)
+      base.extend FriendlyId
+      base.friendly_id :name, use: :slugged
+
       base.include SpreeCmCommissioner::ProductType
 
       base.has_many :variant_kind_option_types, -> { where(kind: :variant).order(:position) },
@@ -10,6 +13,12 @@ module SpreeCmCommissioner
                     through: :option_type_prototypes, source: :option_type
 
       base.has_many :option_values, through: :option_types
+
+      base.preference :icon, :string
+
+      def icon
+        preferred_icon
+      end
     end
   end
 end

data/app/models/spree_cm_commissioner/redis_stock/cached_inventory_items_builder.rb

@@ -0,0 +1,40 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class CachedInventoryItemsBuilder
+      attr_reader :inventory_items
+
+      def initialize(inventory_items)
+        @inventory_items = inventory_items
+      end
+
+      # output: [ CachedInventoryItem(...), CachedInventoryItem(...) ]
+      def call
+        keys = inventory_items.map { |item| "inventory:#{item.id}" }
+        return [] unless keys.any?
+
+        counts = SpreeCmCommissioner.redis_pool.with { |redis| redis.mget(*keys) }
+        inventory_items.map.with_index do |inventory_item, i|
+          ::SpreeCmCommissioner::CachedInventoryItem.new(
+            inventory_key: keys[i],
+            active: inventory_item.active?,
+            quantity_available: cache_inventory(keys[i], inventory_item, counts[i]),
+            inventory_item_id: inventory_item.id,
+            variant_id: inventory_item.variant_id
+          )
+        end
+      end
+
+      private
+
+      def cache_inventory(key, inventory_item, count_in_redis)
+        return count_in_redis.to_i if count_in_redis.present?
+
+        SpreeCmCommissioner.redis_pool.with do |redis|
+          redis.set(key, inventory_item.quantity_available, ex: inventory_item.redis_expired_in)
+        end
+
+        inventory_item.quantity_available
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/redis_stock/inventory_updater.rb

@@ -0,0 +1,114 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class InventoryUpdater
+      class UnableToRestock < StandardError; end
+      class UnableToUnstock < StandardError; end
+
+      def initialize(line_item_ids)
+        @line_item_ids = line_item_ids
+      end
+
+      def unstock!
+        keys, quantities, inventory_ids = extract_inventory_data
+
+        raise UnableToUnstock, Spree.t(:insufficient_stock_lines_present) unless unstock(keys, quantities)
+
+        inventory_id_and_quantities = inventory_ids.map.with_index do |inventory_id, i|
+          { inventory_id: inventory_id, quantity: -quantities[i] }
+        end
+
+        schedule_sync_inventory(inventory_id_and_quantities)
+      end
+
+      def restock!
+        keys, quantities, inventory_ids = extract_inventory_data
+
+        raise UnableToRestock unless restock(keys, quantities)
+
+        inventory_id_and_quantities = inventory_ids.map.with_index do |inventory_id, i|
+          { inventory_id: inventory_id, quantity: quantities[i] }
+        end
+
+        schedule_sync_inventory(inventory_id_and_quantities)
+      end
+
+      private
+
+      def line_items
+        @line_items ||= Spree::LineItem.where(id: @line_item_ids)
+      end
+
+      def unstock(keys, quantities)
+        SpreeCmCommissioner.redis_pool.with do |redis|
+          redis.eval(unstock_redis_script, keys: keys, argv: quantities)
+        end.positive?
+      end
+
+      def restock(keys, quantities)
+        SpreeCmCommissioner.redis_pool.with do |redis|
+          redis.eval(restock_redis_script, keys: keys, argv: quantities)
+        end.positive?
+      end
+
+      # Return: [CachedInventoryItem(...), CachedInventoryItem(...)]
+      def cached_inventory_items
+        @cached_inventory_items ||= SpreeCmCommissioner::RedisStock::LineItemsCachedInventoryItemsBuilder.new(line_item_ids: @line_item_ids)
+                                                                                                         .call.values.flatten
+      end
+
+      def extract_inventory_data
+        keys = []
+        quantities = []
+        inventory_ids = []
+
+        cached_inventory_items.each do |cached_inventory_item|
+          keys << cached_inventory_item.inventory_key
+          quantities << line_items.find { |item| item.variant_id == cached_inventory_item.variant_id }.quantity
+          inventory_ids << cached_inventory_item.inventory_item_id
+        end
+
+        [keys, quantities, inventory_ids]
+      end
+
+      def unstock_redis_script
+        <<~LUA
+          local keys = KEYS
+          local quantities = ARGV
+
+          -- Check availability first
+          for i, key in ipairs(keys) do
+            local current = tonumber(redis.call('GET', key) or 0)
+            if current - tonumber(quantities[i]) < 0 then
+              return 0
+            end
+          end
+
+          -- Apply updates
+          for i, key in ipairs(keys) do
+            redis.call('DECRBY', key, tonumber(quantities[i]))
+          end
+
+          return 1
+        LUA
+      end
+
+      def restock_redis_script
+        <<~LUA
+          local keys = KEYS
+          local quantities = ARGV
+
+          -- Apply restock updates
+          for i, key in ipairs(keys) do
+            redis.call('INCRBY', key, tonumber(quantities[i]))
+          end
+
+          return 1
+        LUA
+      end
+
+      def schedule_sync_inventory(inventory_id_and_quantities)
+        SpreeCmCommissioner::InventoryItemSyncerJob.perform_later(inventory_id_and_quantities:)
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/redis_stock/line_items_cached_inventory_items_builder.rb

@@ -0,0 +1,42 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class LineItemsCachedInventoryItemsBuilder
+      attr_reader :line_item_ids
+
+      def initialize(line_item_ids:)
+        @line_item_ids = line_item_ids
+      end
+
+      # return list of inventory items group by :line_item_id:
+      # {
+      #   1: [ CachedInventoryItem(...), CachedInventoryItem(...) ],
+      #   2: [ CachedInventoryItem(...), CachedInventoryItem(...) ],
+      # }
+      def call
+        cached_inventory_items.group_by do |cached_inventory_item|
+          line_item = line_items.find { |item| item.variant_id == cached_inventory_item.variant_id }
+          line_item.id
+        end
+      end
+
+      def cached_inventory_items
+        @cached_inventory_items ||= SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(inventory_items)
+                                                                                                .call
+      end
+
+      def inventory_items
+        @inventory_items ||= line_items.flat_map do |line_item|
+          # TODO: N+1, we could fix but have a product_type in line item
+          # then include inventory_items in line item directly #2581
+          scope = line_item.inventory_items
+          scope = scope.where(inventory_date: line_item.date_range) if line_item.permanent_stock?
+          scope
+        end
+      end
+
+      def line_items
+        @line_items ||= Spree::LineItem.where(id: line_item_ids).includes(variant: %i[product])
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/redis_stock/variant_cached_inventory_items_builder.rb

@@ -0,0 +1,27 @@
+module SpreeCmCommissioner
+  module RedisStock
+    class VariantCachedInventoryItemsBuilder
+      attr_reader :variant_id, :from_date, :to_date
+
+      def initialize(variant_id:, from_date: nil, to_date: nil)
+        @variant_id = variant_id
+        @from_date = from_date
+        @to_date = to_date
+      end
+
+      # output: [ CachedInventoryItem(...), CachedInventoryItem(...) ]
+      def call
+        ::SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(inventory_items).call
+      end
+
+      def inventory_items
+        variant = Spree::Variant.find(variant_id)
+
+        inventory_items = variant.inventory_items
+        inventory_items.where(inventory_date: from_date..to_date) if variant.permanent_stock?
+
+        inventory_items
+      end
+    end
+  end
+end