spree_cm_commissioner 2.0.0.pre.pre → 2.0.0

data/app/controllers/concerns/spree_cm_commissioner/transit/taxon_bitwise.rb

@@ -0,0 +1,44 @@
+module SpreeCmCommissioner
+  module Transit
+    module TaxonBitwise
+      extend ActiveSupport::Concern
+
+      BIT_STOP = 0b001
+      BIT_STATION = 0b010
+      BIT_BRANCH = 0b100
+      BIT_LOCATION = 0b1000
+
+      included do
+        attr_accessor :stop, :station, :branch, :location
+
+        before_validation :at_least_one_checkbox_selected
+      end
+
+      def stop?
+        data_type & BIT_STOP != 0
+      end
+
+      def station?
+        data_type & BIT_STATION != 0
+      end
+
+      def branch?
+        data_type & BIT_BRANCH != 0
+      end
+
+      def location?
+        data_type & BIT_LOCATION != 0
+      end
+
+      private
+
+      def at_least_one_checkbox_selected
+        if stop.nil? && station.nil? && branch.nil? && location.nil?
+          nil
+        elsif stop.to_i.zero? && station.to_i.zero? && branch.to_i.zero? && location.to_i.zero?
+          errors.add(:base, 'At least one checkbox (stop, branch, or location) must be selected')
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/event_blazer_queries_controller.rb

@@ -2,21 +2,28 @@ module Spree
   module Admin
     class EventBlazerQueriesController < Spree::Admin::ResourceController
       def model_class
-        SpreeCmCommissioner::TaxonBlazerQuery
+        SpreeCmCommissioner::BlazerQueryable
       end
 
       def object_name
-        'spree_cm_commissioner_taxon_blazer_query'
+        'spree_cm_commissioner_blazer_queryable'
       end
 
       def create
-        event_blazer = SpreeCmCommissioner::TaxonBlazerQuery.new(taxon_id: params[:event_id], blazer_query_id: params[:blazer_query_id])
+        queryable = Spree::Taxon.find(params[:event_id])
+
+        event_blazer = SpreeCmCommissioner::BlazerQueryable.new(
+          queryable: queryable,
+          blazer_query_id: params[:blazer_query_id]
+        )
+
         if event_blazer.save
           flash[:success] = I18n.t('event_blazer_queries.success')
         else
           flash[:alert] = event_blazer.errors.full_messages.join(', ')
         end
-        redirect_to blazer.query_path(id: event_blazer.blazer_query_id, event_id: event_blazer.taxon_id)
+
+        redirect_to blazer.query_path(id: event_blazer.blazer_query_id, event_id: queryable.id)
       end
     end
   end

data/app/controllers/spree/admin/stock_managements_controller.rb

@@ -5,8 +5,6 @@ module Spree
 
       before_action :load_parent
 
-      helper_method :inventory_item_message
-
       def load_parent
         @product = Spree::Product.find_by(slug: params[:product_id])
       end
@@ -14,59 +12,9 @@ module Spree
       def index
         @variants = @product.variants.includes(:images, stock_items: :stock_location, option_values: :option_type)
         @variants = [@product.master] if @variants.empty?
-        @stock_locations = (@variants.flat_map(&:stock_locations) + @product.vendor.stock_locations).uniq
-
-        load_inventories unless @product.permanent_stock?
-      end
-
-      def create
-        result = SpreeCmCommissioner::Stock::StockMovementCreator.call(
-          variant_id: params[:variant_id],
-          stock_location_id: params[:stock_location_id],
-          current_store: current_store,
-          stock_movement_params: stock_movement_params
-        )
-
-        if result.success?
-          flash[:success] = flash_message_for(result.stock_movement, :successfully_created)
-        else
-          flash[:error] = result.message
-        end
-
-        redirect_back fallback_location: admin_product_stock_managements_path(@product)
-      end
-
-      # GET /products/:slug/stock_managements/calendar?year=
-      def calendar
-        @year = params[:year].present? ? params[:year].to_i : Time.zone.today.year
 
-        from_date = Date.new(@year, 1, 1).beginning_of_year
-        to_date = Date.new(@year, 1, 1).end_of_year
-
-        @inventory_items = @product.inventory_items.includes(:variant, :prices).where(inventory_date: from_date..to_date).to_a
-        @cached_inventory_items = ::SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(@inventory_items)
-                                                                                                .call
-                                                                                                .index_by(&:inventory_item_id)
-        @events = SpreeCmCommissioner::CalendarEvent.from_inventory_items(@inventory_items)
-      end
-
-      def inventory_item_message(inventory_item, cached_inventory_item)
-        synced = inventory_item.quantity_available == cached_inventory_item.quantity_available
-
-        if synced
-          "Synced: Quantity available matches in both DB and Redis (#{cached_inventory_item.quantity_available})."
-        else
-          "Out of sync: Redis shows #{cached_inventory_item.quantity_available} available, which doesn't match the database."
-        end
-      end
-
-      private
+        @stock_locations = (@variants.flat_map(&:stock_locations) + @product.vendor.stock_locations).uniq
 
-      def load_inventories
-        @inventory_items = @product.inventory_items.group_by { |item| item.variant.id }
-        @cached_inventory_items = ::SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(@product.inventory_items)
-                                                                                                .call
-                                                                                                .index_by(&:inventory_item_id)
         @reserved_stocks = Spree::LineItem
                            .complete
                            .where(variant_id: @variants.pluck(:id))
@@ -77,16 +25,6 @@ module Spree
       def model_class
         Spree::StockItem
       end
-
-      # This method processes the parameters for stock movement creation.
-      # Expected attributes for `stock_movement` include:
-      # - :quantity (Integer): The quantity of stock to move.
-      # - :action (String): The type of stock movement (e.g., "add" or "remove").
-      # - :originator_id, :originator_ty (String, optional): The ID and type of the entity creating the stock movement.
-      # Ensure that `permitted_stock_movement_attributes` is updated to reflect any changes.
-      def stock_movement_params
-        params.require(:stock_movement).permit(permitted_stock_movement_attributes)
-      end
     end
   end
 end

data/app/controllers/spree/admin/tenants_controller.rb

@@ -1,6 +1,8 @@
 module Spree
   module Admin
     class TenantsController < Spree::Admin::ResourceController
+      before_action :load_vector_icons, only: %i[new edit]
+
       # override
       def collection
         params[:q] = {} if params[:q].blank?
@@ -31,6 +33,12 @@ module Spree
       def collection_url(options = {})
         admin_tenants_url(options)
       end
+
+      private
+
+      def load_vector_icons
+        @vector_icons = SpreeCmCommissioner::VectorIcon.all
+      end
     end
   end
 end

data/app/controllers/spree/admin/trip_blazer_queries_controller.rb

@@ -0,0 +1,35 @@
+module Spree
+  module Admin
+    class TripBlazerQueriesController < Spree::Admin::ResourceController
+      def model_class
+        SpreeCmCommissioner::BlazerQueryable
+      end
+
+      def object_name
+        'spree_cm_commissioner_blazer_queryable'
+      end
+
+      def create
+        queryable = SpreeCmCommissioner::Trip.find_by(id: params[:trip_id])
+
+        if queryable.nil?
+          flash[:alert] = I18n.t('trip_blazer_queries.not_found')
+          redirect_to request.referer || spree.admin_trips_path and return
+        end
+
+        trip_blazer = SpreeCmCommissioner::BlazerQueryable.new(
+          queryable: queryable,
+          blazer_query_id: params[:blazer_query_id]
+        )
+
+        if trip_blazer.save
+          flash[:success] = I18n.t('trip_blazer_queries.success')
+        else
+          flash[:alert] = trip_blazer.errors.full_messages.join(', ')
+        end
+
+        redirect_to blazer.query_path(id: trip_blazer.blazer_query_id, trip_id: queryable.id)
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/organizer/invite_crews_controller.rb

@@ -0,0 +1,33 @@
+module Spree
+  module Api
+    module V2
+      module Organizer
+        class InviteCrewsController < ::Spree::Api::V2::Organizer::BaseController
+          def show
+            render_serialized_payload { serialize_resource(invite) }
+          end
+
+          def update
+            context = SpreeCmCommissioner::CrewInviteLinkHandler.call(
+              params: params
+            )
+
+            if context.success?
+              render_serialized_payload { serialize_resource(context.invite) }
+            else
+              render_error_payload(context.message || I18n.t('invite.accept_fail'))
+            end
+          end
+
+          def invite
+            @invite ||= SpreeCmCommissioner::Invite.find_by!(token: params[:id])
+          end
+
+          def resource_serializer
+            ::Spree::V2::Organizer::InviteCrewsSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/organizer/invite_guests_controller.rb

@@ -20,7 +20,7 @@ module Spree
 
             if guest.save
               @invite_guest.update(claimed_status: :claimed) if @line_item.guests.count == @invite_guest.quantity
-              send_guest_claimed_invitation_telegram_alert_to_vendor(guest)
+              send_guest_claimed_invitation_telegram_alert_to_vendor(guest) if guest.event.vendor.preferred_telegram_chat_id.present?
 
               render json: SpreeCmCommissioner::V2::Storefront::GuestSerializer.new(guest.reload).serializable_hash
             else

data/app/controllers/spree/api/v2/storefront/accommodations_controller.rb

@@ -5,38 +5,55 @@ module Spree
         class AccommodationsController < ::Spree::Api::V2::ResourceController
           private
 
-          # override
           def collection
-            @collection ||= SpreeCmCommissioner::Accommodations::Find.new(
-              from_date: params[:from_date]&.to_date,
-              to_date: params[:to_date]&.to_date,
-              state_id: params[:province_id],
-              number_of_adults: params[:adult].to_i,
-              number_of_kids: params[:children].to_i
-            ).execute
+            @collection ||= collection_finder.call(params: params).value
+          end
+
+          def paginated_collection
+            return @paginated_collection if defined?(@paginated_collection)
+
+            @paginated_collection = super
+            @paginated_collection = apply_service_availability(@paginated_collection)
           end
 
-          # override
           def resource
-            @resource ||= collection.find_by!(slug: params[:id])
+            resource = resource_finder.call(params: params).value
+            raise ActiveRecord::RecordNotFound if resource.nil?
+
+            apply_service_availability(resource)
+          end
+
+          def apply_service_availability(resource)
+            SpreeCmCommissioner::ApplyServiceAvailability.call(calendarable: resource,
+                                                               from_date: params[:from_date].to_date,
+                                                               to_date: params[:to_date].to_date
+                                                              ).value
           end
 
-          # override
           def allowed_sort_attributes
             super << :min_price << :max_price
           end
 
-          # override
+          def model_class
+            Spree::Vendor
+          end
+
           def resource_serializer
             Spree::V2::Storefront::AccommodationSerializer
           end
 
-          # override
           def collection_serializer
             Spree::V2::Storefront::AccommodationSerializer
           end
 
-          # override
+          def collection_finder
+            SpreeCmCommissioner::AccommodationSearchDetail
+          end
+
+          def resource_finder
+            SpreeCmCommissioner::AccommodationSearchDetail
+          end
+
           def required_schema
             SpreeCmCommissioner::AccommodationRequestSchema
           end

data/app/controllers/spree/api/v2/storefront/dynamic_field_options_controller.rb

@@ -8,7 +8,11 @@ module Spree
             return @collection if defined?(@collection)
             return SpreeCmCommissioner::DynamicFieldOption.none if params[:dynamic_field_id].blank?
 
-            @collection = SpreeCmCommissioner::DynamicFieldOption.where(dynamic_field_id: params[:dynamic_field_id])
+            @collection = SpreeCmCommissioner::DynamicFieldOption
+                          .where(dynamic_field_id: params[:dynamic_field_id])
+                          .active
+                          .order(position: :asc)
+
             @collection = @collection.where('value LIKE ?', "%#{params[:query]}%") if params[:query].present?
             @collection
           end

data/app/controllers/spree/api/v2/storefront/guests_controller.rb

@@ -38,10 +38,25 @@ module Spree
           def update
             spree_authorize! :update, spree_current_order, order_token
 
-            if resource.update(guest_params)
+            begin
+              ActiveRecord::Base.transaction do
+                if guest_params[:guest_dynamic_fields_attributes]
+                  dynamic_field_ids = guest_params[:guest_dynamic_fields_attributes].pluck(:dynamic_field_id)
+                  resource.guest_dynamic_fields.where(dynamic_field_id: dynamic_field_ids).destroy_all
+
+                  guest_params[:guest_dynamic_fields_attributes].each do |attr|
+                    field = build_dynamic_field(attr)
+                    field.save!
+                  end
+                end
+
+                resource.assign_attributes(guest_params.except(:guest_dynamic_fields_attributes))
+                resource.save!
+              end
+
               render_serialized_payload { serialize_resource(resource) }
-            else
-              render_error_payload(resource, 400)
+            rescue ActiveRecord::RecordInvalid => e
+              render_error_payload(e.record.errors, 400)
             end
           end
 
@@ -76,9 +91,20 @@ module Spree
               :upload_later,
               :country_code,
               :contact,
-              guest_dynamic_fields_attributes: %i[id dynamic_field_id value _destroy]
+              guest_dynamic_fields_attributes: %i[id dynamic_field_id dynamic_field_option_id value _destroy]
             )
           end
+
+          def build_dynamic_field(attr)
+            field = resource.guest_dynamic_fields.build(attr.except(:id))
+
+            if field.dynamic_field.requires_dynamic_field_options?
+              option = field.dynamic_field.dynamic_field_options.find_by(id: field.value)
+              field.dynamic_field_option = option if option
+            end
+
+            field
+          end
         end
       end
     end

data/app/controllers/spree/api/v2/storefront/queue_cart/line_items_controller.rb

@@ -12,9 +12,9 @@ module Spree
               spree_authorize! :update, spree_current_order, order_token
               spree_authorize! :show, @variant
 
-              availability_checker = SpreeCmCommissioner::Stock::AvailabilityChecker.new(@variant, add_item_params[:options])
+              availability_checker = SpreeCmCommissioner::Stock::AvailabilityChecker.new(@variant)
 
-              unless availability_checker.can_supply?(add_item_params[:quantity].to_i)
+              unless availability_checker.can_supply?(add_item_params[:quantity].to_i, add_item_params[:options])
                 return render_error_payload(availability_checker.error_message || I18n.t('variant_availability.items_out_of_stock'))
               end
 

data/app/controllers/spree/api/v2/tenant/checkout_controller.rb

@@ -27,6 +27,8 @@ module Spree
           end
 
           def complete
+            return render_serialized_payload { serialized_current_order } if spree_current_order.confirm? || spree_current_order.complete?
+
             spree_authorize! :update, spree_current_order, order_token
 
             result = complete_service.call(order: spree_current_order)

data/app/controllers/spree_cm_commissioner/admin/variants_controller_decorator.rb

@@ -37,7 +37,7 @@ module SpreeCmCommissioner
         bit_fields = SpreeCmCommissioner::KycBitwise::BIT_FIELDS.keys
 
         if permitted_resource_params[:use_product_kyc] == '1'
-          permitted_resource_params[:kyc] = @product.kyc
+          permitted_resource_params[:kyc] = nil
         else
           @kyc_result = calculate_kyc_value(params[:variant])
           permitted_resource_params[:kyc] = @kyc_result

data/app/controllers/spree_cm_commissioner/api/v2/storefront/checkout_controller_decorator.rb

@@ -6,6 +6,17 @@ module SpreeCmCommissioner
           def self.prepended(base)
             base.include SpreeCmCommissioner::OrderConcern
           end
+
+          # Override Spree's default behavior:
+          # By default, Spree raises an error if `complete` is called on a completed or confirmed order.
+          # We want to allow this call to succeed, so the API can be used both to:
+          # - complete the order (if it's not yet complete), or
+          # - return the latest state of a confirmed or completed order without raising a forbidden error.
+          def complete
+            return render_serialized_payload { serialized_current_order } if spree_current_order.confirm? || spree_current_order.complete?
+
+            super
+          end
         end
       end
     end

data/app/controllers/spree_cm_commissioner/well_known_controller.rb

@@ -3,18 +3,42 @@ module SpreeCmCommissioner
     before_action :identify_request_source
     rescue_from StandardError, with: :handle_error
 
-    def show
-      case params[:id]
-      when 'assetlinks.json'
-        render_preference(:preferred_assetlinks)
-      when 'apple-app-site-association'
-        render_preference(:preferred_apple_app_site_association)
+    def assetlinks_json
+      render_platform_link(:android)
+    end
+
+    def apple_app_site_association
+      render_platform_link(:ios)
+    end
+
+    private
+
+    def render_platform_link(platform)
+      fetcher_class = platform_link_finder(platform)
+
+      result = fetcher_class.call(
+        store: @store,
+        tenant: @tenant,
+        refreshed: params[:_refreshed].present?
+      )
+
+      if result.success? && result.contents.present?
+        render json: result.contents
       else
         render_not_found
       end
     end
 
-    private
+    def platform_link_finder(platform)
+      case platform
+      when :android
+        SpreeCmCommissioner::AssetLinksFetcher
+      when :ios
+        SpreeCmCommissioner::AppleAppSiteAssociationFetcher
+      else
+        render_not_found
+      end
+    end
 
     def identify_request_source
       host = params[:original_host].presence || request.host.downcase
@@ -25,16 +49,6 @@ module SpreeCmCommissioner
       @tenant = result.tenant
     end
 
-    def render_preference(preference_key)
-      if @store&.send(preference_key).present?
-        render json: @store.send(preference_key)
-      elsif @tenant&.send(preference_key).present?
-        render json: @tenant.send(preference_key)
-      else
-        render_not_found
-      end
-    end
-
     def render_not_found
       render json: { error: 'Not found' }, status: :not_found
     end

data/app/factory/spree_cm_commissioner/invite_guest_claimed_telegram_message_factory.rb

@@ -1,26 +1,16 @@
-# 🎟️ --- [TICKET CLAIMED] ---
+# 🎫 --- [NEW INVITATION CLAIMED] ---
 #
-# Order Number:
-# <code>R621016753</code>
-#
-# ✅ <b>Ticket Successfully Claimed!</b>
-#
-# [ x1 ]
-# <b>5km Running Ticket</b>
-# <i>👉 Distance: 5km, T-shirt: M</i>
-# <i>🗓️ Nov 15, 2023</i>
-# <i>🏪 Temple Run with Sai</i>
+# <b>🙍 Claimed By</b>
+# Name: Orng SreyMoch
+# Tel: <code>+85570760548</code>
 #
-# [ x2 ]
 # <b>5km Running Ticket</b>
+# Quantity: 1
 # <i>👉 Distance: 5km, T-shirt: S</i>
 # <i>🗓️ Nov 15, 2023 -> Nov 17, 2023</i>
-# <i>🏪 Temple Run with Sai</i>
 #
-# <b>🙍 Claimed By</b>
-# Name: Vaneath Awesome
-# Tel: <code>+85570760548</code>
-# Email: <code>admin_dev@cm.com</code>
+# Order Number:
+# <code>R621016753</code>
 
 module SpreeCmCommissioner
   class InviteGuestClaimedTelegramMessageFactory < TelegramMessageFactory
@@ -36,85 +26,37 @@ module SpreeCmCommissioner
     end
 
     def selected_line_items
-      return order.line_items.for_vendor(vendor) if vendor.present?
-
-      order.line_items
+      vendor.present? ? order.line_items.for_vendor(vendor) : order.line_items
     end
 
     # override
     def body
       text = []
-      text << "Order Number:\n<code>#{order.number}</code>\n"
-      text << "\n✅ <b>Ticket Successfully Claimed!</b>\n"
-      text << selected_line_items.map { |item| line_item_content(item) }.compact.join("\n\n")
-      text.compact.join("\n")
-    end
 
-    def line_item_content(line_item)
-      text = []
+      text << bold('🙍 Claimed By')
+      text << "Name: #{guest.first_name} #{guest.last_name}"
+      text << "Tel: #{inline_code(guest.phone_number)}"
+      text << ''
+
+      selected_line_items.each do |item|
+        text << bold(item.product.name.to_s)
+        text << "🎟️ Quantity: #{item.quantity}"
+        text << italic("👉 #{item.options_text}") if item.options_text.present?
+        text << italic(pretty_date_for(item)) if item.date_present?
+        text << ''
+      end
 
-      text << bold(line_item.product.name.to_s)
-      text << "Quantity: #{line_item.quantity}"
-      text << italic("👉 #{line_item.options_text}") if line_item.options_text.present?
-      text << italic(pretty_date_for(line_item)) if pretty_date_for(line_item).present?
-      text << italic("🏪 #{line_item.vendor.name}") if line_item.vendor&.name.present? && vendor.blank?
+      text << bold('Order Number:')
+      text << inline_code(order.number)
 
       text.compact.join("\n")
     end
 
     def pretty_date_for(line_item)
-      return nil unless line_item.date_present?
-
       from_date = pretty_date(line_item.from_date)
       to_date = pretty_date(line_item.to_date)
 
-      if from_date == to_date
-        "🗓️ #{from_date}"
-      else
-        "🗓️ #{from_date} -> #{to_date}"
-      end
-    end
-
-    # override
-    def footer
-      text = []
-
-      text << bold('🙍 Claimed By')
-      text << "Name: #{guest.first_name} #{guest.last_name}" if guest.first_name.present? || guest.last_name.present?
-      text << "Tel: #{inline_code(guest.intel_phone_number)}" if guest.intel_phone_number.present?
-
-      if show_details_link && order.guests.any?
-        text << ''
-        text << 'View Tickets:'
-        text += generate_guests_links(order.guests)
-      end
-
-      text.compact.join("\n")
-    end
-
-    # Result:
-    # | No. A24 | No. A24 |
-    # | No. A24 | No. A24 |
-    # | No. A24 | No. A24 |
-    # | No. A24 | No. A24 |
-    # | No. A24 | No. A24 |
-    # | No. A24 |
-    def generate_guests_links(guests, guests_per_row = 2)
-      rows = (guests.size.to_f / guests_per_row).ceil
-      formatted_rows = []
-
-      rows.times do |i|
-        row_guests = guests.slice(i * guests_per_row, guests_per_row)
-        formatted_row = row_guests.map do |guest|
-          button_label = guest.seat_number.present? ? "No. #{guest.seat_number}" : "No. #{guest.formatted_bib_number || 'N/A'}"
-          link = Rails.application.routes.url_helpers.guest_cards_url(guest.token)
-          "| <a href='#{link}'>#{button_label}</a>"
-        end.join(' ')
-
-        formatted_rows << ("#{formatted_row} |")
-      end
-
-      formatted_rows
+      from_date == to_date ? "🗓️ #{from_date}" : "🗓️ #{from_date} -> #{to_date}"
     end
   end
 end

data/app/finders/spree_cm_commissioner/line_items/find_by_variant_decorator.rb

@@ -0,0 +1,20 @@
+module SpreeCmCommissioner
+  module LineItems
+    module FindByVariantDecorator
+      # ovveride
+      def execute(order:, variant:, options: {})
+        return super unless variant.product.product_type == 'transit'
+
+        order.line_items.detect do |line_item|
+          next if options[:date].present? && !(line_item.variant_id == variant.id && line_item.date == options[:date])
+
+          Spree::Dependencies.cart_compare_line_items_service.constantize.call(order: order, line_item: line_item, options: options).value
+        end
+      end
+    end
+  end
+end
+
+unless Spree::LineItems::FindByVariant.included_modules.include?(SpreeCmCommissioner::LineItems::FindByVariantDecorator)
+  Spree::LineItems::FindByVariant.prepend(SpreeCmCommissioner::LineItems::FindByVariantDecorator)
+end