spree_cm_commissioner 1.10.0.pre.pre → 1.10.0.pre.hotfix.pre.sms

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

@@ -13,13 +13,10 @@ 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') }
 
@@ -69,29 +66,6 @@ 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,20 +6,10 @@ 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/concerns/spree_cm_commissioner/user_identity.rb

@@ -25,18 +25,21 @@ module SpreeCmCommissioner
     end
 
     class_methods do
-      def find_user_by_login(login)
+      def find_user_by_login(login, tenant_id)
         return nil if login.blank?
 
         login = login.downcase
         parser = PhoneNumberParser.call(phone_number: login)
 
+        scope = Spree.user_class.all
+        scope = scope.where(tenant_id: tenant_id) if tenant_id.present?
+
         if parser.intel_phone_number.present?
-          find_by(intel_phone_number: parser.intel_phone_number)
+          scope.find_by(intel_phone_number: parser.intel_phone_number)
         elsif login =~ URI::MailTo::EMAIL_REGEXP
-          find_by(email: login)
+          scope.find_by(email: login)
         else
-          find_by(login: login)
+          scope.find_by(login: login)
         end
       end
     end

data/app/models/spree_cm_commissioner/cms_page_decorator.rb

@@ -0,0 +1,9 @@
+module SpreeCmCommissioner
+  module CmsPageDecorator
+    def self.prepended(base)
+      base.multi_tenant :tenant, class_name: 'SpreeCmCommissioner::Tenant'
+    end
+  end
+end
+
+Spree::CmsPage.prepend(SpreeCmCommissioner::CmsPageDecorator) unless Spree::CmsPage.included_modules.include?(SpreeCmCommissioner::CmsPageDecorator)

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -9,7 +9,6 @@ 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,13 +58,6 @@ 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?
 
@@ -201,14 +194,6 @@ 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/place.rb

@@ -2,6 +2,8 @@ require_dependency 'spree_cm_commissioner'
 
 module SpreeCmCommissioner
   class Place < ApplicationRecord
+    acts_as_nested_set
+
     validates :reference, presence: true, if: :validate_reference?
     validates :lat, presence: true, if: :validate_lat?
     validates :lon, presence: true, if: :validate_lon?
@@ -13,15 +15,22 @@ module SpreeCmCommissioner
 
     has_many :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
     has_many :products, through: :product_places
-    has_many :children, class_name: 'SpreeCmCommissioner::Place', foreign_key: :parent_id, dependent: :destroy
-    belongs_to :parent, class_name: 'SpreeCmCommissioner::Place', optional: true
 
+    has_many :children, -> { order(:lft) }, class_name: 'SpreeCmCommissioner::Place', foreign_key: :parent_id, dependent: :destroy
     has_many :vendor_stops, class_name: 'SpreeCmCommissioner::VendorStop', dependent: :destroy
 
     def self.ransackable_attributes(auth_object = nil)
       super & %w[name code]
     end
 
+    def full_path_name
+      self_and_ancestors.map(&:name).reverse.join(', ')
+    end
+
+    def path_ids
+      self_and_ancestors.map(&:id)
+    end
+
     def validate_reference?
       Spree::Store.default.code.exclude?('billing')
     end

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -33,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 :product_places, class_name: 'SpreeCmCommissioner::ProductPlace', dependent: :destroy
       base.has_many :places, through: :product_places

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

@@ -1,49 +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?
-
-          @cached_inventory_items = builder_klass.new(
-            variant_id: variant.id,
-            from_date: options[:from_date].to_date,
-            to_date: options[:to_date].to_date
-          ).call
+          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/taxon_decorator.rb

@@ -57,6 +57,9 @@ module SpreeCmCommissioner
       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 :taxon_option_types, class_name: 'SpreeCmCommissioner::TaxonOptionType'
+      base.has_many :taxon_option_values, class_name: 'SpreeCmCommissioner::TaxonOptionValue'
+
       def base.active_homepage_events
         joins(:homepage_section_relatables)
           .joins("INNER JOIN spree_taxons taxon ON taxon.id = cm_homepage_section_relatables.relatable_id
@@ -96,6 +99,14 @@ module SpreeCmCommissioner
                        .uniq
     end
 
+    def selected_option_types
+      taxon_option_types.pluck(:option_type_id)
+    end
+
+    def selected_option_values
+      taxon_option_values.pluck(:option_value_id)
+    end
+
     def event_url
       "https://#{Spree::Store.default.url}/t/#{permalink}"
     end

data/app/models/spree_cm_commissioner/taxon_option_type.rb

@@ -0,0 +1,8 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class TaxonOptionType < ApplicationRecord
+    belongs_to :taxon, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :option_type, class_name: 'Spree::OptionType', dependent: :destroy
+  end
+end

data/app/models/spree_cm_commissioner/taxon_option_value.rb

@@ -0,0 +1,8 @@
+require_dependency 'spree_cm_commissioner'
+
+module SpreeCmCommissioner
+  class TaxonOptionValue < ApplicationRecord
+    belongs_to :taxon, class_name: 'Spree::Taxon', dependent: :destroy
+    belongs_to :option_value, class_name: 'Spree::OptionValue', dependent: :destroy
+  end
+end

data/app/models/spree_cm_commissioner/trip.rb

@@ -14,23 +14,12 @@ module SpreeCmCommissioner
     validates :duration, numericality: { greater_than: 0 }
     validate :origin_and_destination_cannot_be_the_same
 
-    has_many :trip_stops, class_name: 'SpreeCmCommissioner::TripStop', dependent: :destroy
-
-    after_commit :create_trip_stops
-
-    accepts_nested_attributes_for :trip_stops, allow_destroy: true
-
     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.create(stop_type: :boarding, stop_id: origin_id)
-      trip_stops.create(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

@@ -5,6 +5,7 @@ module SpreeCmCommissioner
 
     validate :both_trip_cannot_be_the_same
     before_validation :calculate_connection_time_minutes
+    validates :from_trip_id, uniqueness: { scope: :to_trip_id }
 
     private
 

data/app/models/spree_cm_commissioner/trip_stop.rb

@@ -8,22 +8,29 @@ module SpreeCmCommissioner
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
     before_validation :set_stop_name
-    after_create :create_vendor_stop
-
+    after_destroy :decrement_trip_count
+    after_commit :create_vendor_stop
     validates :stop_id, uniqueness: { scope: :trip_id }
 
     def set_stop_name
-      self.stop_name = stop.name
+      self.stop_name = stop.name if stop.present?
     end
 
     def create_vendor_stop
-      vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).first_or_create
+      vendor_stop = vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).first_or_create
+      vendor_stop.update(trip_count: vendor_stop.trip_count.to_i + 1)
     end
 
     private
 
+    def decrement_trip_count
+      vendor.vendor_stops.where(stop_id: stop_id, stop_type: stop_type).find_each do |vendor_stop|
+        vendor_stop.update(trip_count: [vendor_stop.trip_count - 1, 0].max)
+      end
+    end
+
     def vendor
-      Spree::Product.find(trip.product_id).vendor
+      Spree::Product.find(trip&.product_id).vendor
     end
   end
 end

data/app/models/spree_cm_commissioner/variant_decorator.rb

@@ -1,7 +1,6 @@
 module SpreeCmCommissioner
   module VariantDecorator
     def self.prepended(base)
-      base.include SpreeCmCommissioner::ProductType
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::VariantOptionsConcern
 
@@ -22,16 +21,21 @@ module SpreeCmCommissioner
       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, -> { joins(:product).where(product: { product_type: base::PERMANENT_STOCK_PRODUCT_TYPES }) }
-      base.scope :with_non_permanent_stock, -> { joins(:product).where.not(product: { 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: -> { product.product_type == 'transit' }
+      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?
+
+      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?
@@ -47,24 +51,12 @@ module SpreeCmCommissioner
       super || product.discontinued?
     end
 
-    def event
-      taxons.event.first
-    end
-
-    def default_inventory_item_exist?
-      inventory_items.exists?(inventory_date: nil)
+    def permanent_stock?
+      accommodation?
     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 event
+      taxons.event.first
     end
 
     # override
@@ -87,12 +79,23 @@ module SpreeCmCommissioner
     end
 
     # override
-    def in_stock?(options = {})
-      SpreeCmCommissioner::Stock::AvailabilityChecker.new(self, options).can_supply?
+    def in_stock?
+      available_quantity.positive?
     end
 
     private
 
+    def total_purchases
+      Spree::LineItem.complete.where(variant_id: id).sum(:quantity).to_i
+    end
+
+    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&.product_type == vendor&.primary_product_type
 

data/app/models/spree_cm_commissioner/variant_options.rb

@@ -166,19 +166,5 @@ module SpreeCmCommissioner
         Time.zone.parse(time) if time.present?
       end
     end
-
-    def arrival_time
-      @arrival_time ||= departure_time + total_duration_in_minutes.minutes
-    end
-
-    def total_duration_in_minutes
-      total_duration_in_minutes = 0
-
-      total_duration_in_minutes += duration_in_hours * 60 if duration_in_hours.present?
-      total_duration_in_minutes += duration_in_minutes if duration_in_minutes.present?
-      total_duration_in_minutes += duration_in_seconds / 60 if duration_in_seconds.present?
-
-      total_duration_in_minutes
-    end
   end
 end

data/app/models/spree_cm_commissioner/vehicle.rb

@@ -8,7 +8,6 @@ module SpreeCmCommissioner
     has_one :primary_photo, -> { order(position: :asc) }, class_name: 'SpreeCmCommissioner::VehiclePhoto', as: :viewable, dependent: :destroy
     belongs_to :vendor, class_name: 'Spree::Vendor'
 
-    before_save :set_attributes
     after_commit :create_vehicle_option_value
 
     has_many :vehicle_photo, class_name: 'SpreeCmCommissioner::VehiclePhoto', as: :viewable, dependent: :destroy
@@ -17,12 +16,6 @@ module SpreeCmCommissioner
     validates :code, uniqueness: { scope: :vendor_id }, presence: true
     validates :license_plate, uniqueness: {}, allow_blank: true
 
-    def set_attributes
-      self.route_type = vehicle_type.route_type
-      self.number_of_seats = vehicle_type.vehicle_seats_count
-      self.allow_seat_selection = vehicle_type.allow_seat_selection
-    end
-
     def create_vehicle_option_value
       SpreeCmCommissioner::VehicleOptionValueCreator.call(self)
     end

data/app/models/spree_cm_commissioner/vendor_decorator.rb

@@ -79,7 +79,8 @@ module SpreeCmCommissioner
                     dependent: :destroy, inverse_of: :relatable
 
       base.has_many :vehicle_types, class_name: 'SpreeCmCommissioner::VehicleType', dependent: :destroy
-      base.has_many :vehicles, through: :vehicle_types, class_name: 'SpreeCmCommissioner::Vehicle', dependent: :destroy
+      base.has_many :vehicles, class_name: 'SpreeCmCommissioner::Vehicle', dependent: :destroy
+      # base.has_many :vehicles, through: :vehicle_types, class_name: 'SpreeCmCommissioner::Vehicle', dependent: :destroy
 
       base.validates :account_name, :account_number, presence: true, if: lambda {
                                                                            payment_qrcode.present? && Spree::Store.default.code.include?('billing')

data/app/models/spree_cm_commissioner/vendor_stop.rb

@@ -4,6 +4,7 @@ module SpreeCmCommissioner
     belongs_to :vendor, class_name: 'Spree::Vendor'
     belongs_to :stop, class_name: 'SpreeCmCommissioner::Place'
 
-    enum stop_type: { boarding: 0, drop_off: 1 }
+    validates :trip_count, numericality: { greater_than_or_equal_to: 0 }
+    enum :stop_type, { boarding: 0, drop_off: 1 }
   end
 end

data/app/overrides/spree/admin/cms_pages/_form/tenant_fields.html.erb.deface

@@ -0,0 +1,7 @@
+<!-- insert_before "erb[loud]:contains('f.field_container :title')" -->
+
+<%= f.field_container :tenant_id, class: ['col-12'] do %>
+  <%= f.label :tenant_id, raw(Spree.t(:tenant) + ' (optional)') %>
+  <%= f.collection_select :tenant_id, SpreeCmCommissioner::Tenant.all, :id, :name, { prompt: Spree.t('select_tenant') }, { class: 'form-control select2' } %>
+  <%= f.error_message_on :tenant_id %>
+<% end %>

data/app/overrides/spree/admin/cms_pages/index/cms_pages_tabs.html.erb.deface

@@ -0,0 +1,21 @@
+<!-- insert_before "erb[silent]:contains('content_for :page_actions')" -->
+
+<%= render partial: 'spree/admin/shared/cms_pages_tabs' %>
+
+<% if params[:tab] == 'default' %>
+  <div class="alert alert-info mb-3">
+    <%= svg_icon name: "info-circle.svg", classes: 'mr-2', width: '16', height: '16' %>
+    CMS Pages for the default store. These pages are shared globally and are not tied to any specific tenant.
+  </div>
+<% elsif params[:tab] == 'tenants' && params[:tenant_id].present? %>
+  <div class="alert alert-info mb-3">
+    <%= svg_icon name: "info-circle.svg", classes: 'mr-2', width: '16', height: '16' %>
+    CMS Pages for the tenant: <strong><%= SpreeCmCommissioner::Tenant.find(params[:tenant_id]).name %></strong>.
+    These pages are displayed only to users associated with this tenant.
+  </div>
+<% elsif params[:tab] == 'tenants' %>
+  <div class="alert alert-info mb-3">
+    <%= svg_icon name: "info-circle.svg", classes: 'mr-2', width: '16', height: '16' %>
+    CMS Pages for all tenants. These pages are displayed only to users associated with specific tenants.
+  </div>
+<% end %>

data/app/overrides/spree/admin/users/index/body.html.erb.deface

@@ -23,6 +23,9 @@
   <td class='phone_number'>
     <%= user.phone_number%>
   </td>
+  <td class='tenant'>
+    <%= user.tenant&.name || Spree::Store.default.name %>
+  </td>
   <td class='created_at'>
     <%= user.created_at %>
   </td>

data/app/overrides/spree/admin/users/index/headers.html.erb.deface

@@ -19,6 +19,9 @@
      <th>
       <%= sort_link @search, :phone_number,  I18n.t('activerecord.attributes.spree/order.phone_number'), {}, {title: 'phone_number_title'} %>
     </th>
+    <th>
+      <%= Spree.t(:tenant) %>
+    </th>
     <th>
       <%= sort_link @search, :created_at, Spree.t(:create_at), {}, {title: 'create_at_title'} %>
     </th>