spree_cm_commissioner 2.14.5 → 2.14.7

data/app/models/spree_cm_commissioner/maintenance_tasks/cache_invalidation.rb

@@ -1,30 +1,114 @@
-# Class for invalidating cache across all models.
+# One CloudFront invalidation, queued automatically on save (debounced by OrchestrateJob) or by a
+# clear-cache click (ApiCaches::RequestClear), and kept as the record's clear-cache history.
+#
+# A clear-all (every record of a model on one storefront, ApiCaches::InvalidateAll) is a task too,
+# so it is queued, deduplicated and shown in the clear-cache dialog's history like any other clear,
+# and counts towards its cooldown. It has no record of its own, so its maintainable is the
+# storefront it clears: the SpreeCmCommissioner::Tenant, or the default Spree::Store for BookMe+'s.
+# Clear-alls of every model share that maintainable, so the model is stored (invalidation_model).
 module SpreeCmCommissioner
   module MaintenanceTasks
     class CacheInvalidation < MaintenanceTask
+      OUTCOMES = %w[sent skipped failed].freeze
+      STOREFRONT_TYPES = %w[SpreeCmCommissioner::Tenant Spree::Store].freeze
+
+      store_private_metadata :triggered_by_id, :integer
+      store_private_metadata :outcome, :string
+      store_private_metadata :invalidation_model, :string
+
+      # For finding the invalidation in the AWS console.
+      store_private_metadata :cloudfront_invalidation_id, :string
+
       def maintain
-        if ENV['CACHE_AUTO_INVALIDATION_DISABLED'] == 'yes'
-          log_invalidation('skipped: CACHE_AUTO_INVALIDATION_DISABLED')
+        # The switch is for automatic invalidations only; a click is someone asking for one now.
+        if ENV['CACHE_AUTO_INVALIDATION_DISABLED'] == 'yes' && !manually_triggered?
+          record_outcome('skipped', message: 'CACHE_AUTO_INVALIDATION_DISABLED')
           return
         end
 
-        result = SpreeCmCommissioner::ApiCaches::Invalidate.call(model: maintainable.class.name, id: maintainable.id)
+        result = refresh_records
+        return record_failure(result.error.to_s) if result.failure?
 
-        if result.success?
-          log_invalidation('sent', patterns: result.value[:api_patterns])
-        else
-          log_invalidation("failed: #{result.error}")
+        patterns = result.value[:api_patterns]
+
+        # CloudFront rejects an empty batch, e.g. homepage backgrounds on a tenant's API.
+        return record_outcome('skipped', message: 'no API serves it on this storefront') if patterns.empty?
+
+        send_invalidation(patterns)
+      end
+
+      # The task's maintainable for a clear of model: the record with id, or for a clear-all (no id)
+      # the storefront, see above. nil for anything that can't be cleared.
+      def self.maintainable_for(model:, id: nil, tenant: nil)
+        if id.present?
+          SpreeCmCommissioner::ApiCaches::Invalidate::SUPPORTED_MODELS[model]&.find_by(id: id)
+        elsif SpreeCmCommissioner::ApiCaches::InvalidateAll::API_PATTERNS.key?(model)
+          tenant || Spree::Store.default
+        end
+      end
+
+      # Only a clear-all hangs off a storefront rather than the record it clears.
+      def invalidate_all?
+        STOREFRONT_TYPES.include?(maintainable_type)
+      end
+
+      def target_model
+        invalidation_model.presence || maintainable.class.name
+      end
+
+      # :queued until the job runs, and :failed once it has used up its retries.
+      def clear_status
+        return attempt_count >= MAX_ATTEMPTS ? :failed : :queued if completed_at.nil?
+
+        case outcome.presence || legacy_outcome
+        when 'sent' then :sent
+        when 'skipped' then :skipped
+        else :failed
         end
       end
 
       private
 
+      def refresh_records
+        if invalidate_all?
+          tenant = maintainable if maintainable.is_a?(SpreeCmCommissioner::Tenant)
+          SpreeCmCommissioner::ApiCaches::InvalidateAll.call(model: target_model, tenant: tenant)
+        else
+          SpreeCmCommissioner::ApiCaches::Invalidate.call(model: target_model, id: maintainable_id)
+        end
+      end
+
+      # Synchronous, since this already runs in ProcessJob, so the task only says sent once CloudFront
+      # has accepted it. Errors other than CloudFront's own refusal raise, so the task is retried.
+      def send_invalidation(patterns)
+        request = SpreeCmCommissioner::InvalidateCacheRequest.call(patterns: patterns)
+        return record_failure(request.message) if request.failure?
+
+        self.cloudfront_invalidation_id = request.response.invalidation.id
+        record_outcome('sent', message: patterns.join(', '))
+      end
+
+      # Tasks completed before `outcome` was stored only have it in their log line.
+      def legacy_outcome
+        track_messages.reverse_each do |message|
+          match = message.match(/\AInvalidation (\w+)/)
+          return match[1] if match && OUTCOMES.include?(match[1])
+        end
+        nil
+      end
+
+      def record_failure(error)
+        self.last_error = error
+        record_outcome('failed', message: error)
+      end
+
       # Each path costs money on CloudFront, so every outcome is logged and kept on the task for troubleshooting.
-      def log_invalidation(outcome, patterns: [])
-        log_run("Invalidation #{outcome} #{patterns.join(', ')}".strip)
+      def record_outcome(outcome, message:)
+        self.outcome = outcome
+        log_run("Invalidation #{outcome}: #{message}")
         CmAppLogger.log(
           label: "#{self.class.name} #{outcome}",
-          data: { maintenance_task_id: id, maintainable_type: maintainable_type, maintainable_id: maintainable_id, patterns: patterns }
+          data: { maintenance_task_id: id, maintainable_type: maintainable_type, maintainable_id: maintainable_id, message: message }
         )
       end
     end

data/app/models/spree_cm_commissioner/pin_code.rb

@@ -139,7 +139,8 @@ module SpreeCmCommissioner
         'SpreeCmCommissioner::PinCodeUpdateUserLogin' => I18n.t('pincode.readable_type.update_user_login'),
         'SpreeCmCommissioner::PinCodeEmailConfirm' => I18n.t('pincode.readable_type.confirmation_code'),
         'SpreeCmCommissioner::PinCodeOtp' => I18n.t('pincode.readable_type.otp_code'),
-        'SpreeCmCommissioner::PinCodeTelegram' => I18n.t('pincode.readable_type.telegram_verification')
+        'SpreeCmCommissioner::PinCodeTelegram' => I18n.t('pincode.readable_type.telegram_verification'),
+        'SpreeCmCommissioner::PinCodeEventTelegram' => I18n.t('pincode.readable_type.telegram_verification')
       }
     end
 

data/app/models/spree_cm_commissioner/pin_code_event_telegram.rb

@@ -0,0 +1,31 @@
+module SpreeCmCommissioner
+  # PIN for connecting an event's order-alert Telegram group; `contact` is the event (Spree::Taxon) id.
+  # Not a PinCodeTelegram subclass on purpose: STI queries on PinCodeTelegram would then also return
+  # these rows, and an event id equal to a vendor id would surface as that vendor's PIN.
+  class PinCodeEventTelegram < PinCode
+    before_validation :set_telegram_attrs, on: :create
+    validates :contact, presence: true, numericality: { only_integer: true }
+
+    belongs_to :event, class_name: 'Spree::Taxon', 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::PinCodeEventTelegram'
+      self.expired_at = Time.zone.now + expires_in_seconds unless expired_at
+    end
+  end
+end

data/app/models/spree_cm_commissioner/service_calendar.rb

@@ -33,13 +33,13 @@ module SpreeCmCommissioner
       end
     end
 
-    private
-
     def set_dates
       self.start_date = Date.new(2000, 1, 1) if start_date.blank?
       self.end_date   = Date.new(2100, 1, 1) if end_date.blank?
     end
 
+    private
+
     def in_weekly_service?(date)
       day_name = date.strftime('%A').downcase
       send(day_name.to_sym)

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -51,6 +51,13 @@ module SpreeCmCommissioner
 
       base.store_public_metadata :live_stock_path, :string
 
+      # The event's own order-alert Telegram group, connected from the organizer event page. When set,
+      # this event's line items alert here instead of the vendor's group. Private so the chat id never
+      # reaches storefront serializers.
+      base.store_private_metadata :telegram_alert_chat_id, :string
+      base.store_private_metadata :telegram_alert_chat_name, :string
+      base.store_private_metadata :telegram_alert_chat_type, :string
+
       base.before_save :set_kind
       base.before_save :set_slug
       base.before_save :normalize_custom_redirect_url

data/app/models/spree_cm_commissioner/vendor_decorator.rb

@@ -253,6 +253,12 @@ module SpreeCmCommissioner
       "#{Spree::Store.default.formatted_url}/organizers/#{slug}"
     end
 
+    def find_event_by_id(event_id: nil)
+      return nil if event_id.blank?
+
+      taxons.events.find_by(slug: "events-#{event_id}")
+    end
+
     # Deep links to the public hotel detail page with a default 1-room/2-adult, 2-night search
     # pre-filled — same query params the storefront's hotel page reads (see cm-market-client's
     # JsonLd::HotelRequest), so "View Profile" previews the real booking page instead of the

data/app/queries/spree_cm_commissioner/trip_query.rb

@@ -13,16 +13,34 @@ module SpreeCmCommissioner
       @options = options
     end
 
+    # Every matching trip, unless the client asks for pages with `per_page`: the apps sort and filter the full
+    # list locally, so a default page size would silently drop trips (Kaminari.paginate_array cuts to 25).
     def call
-      return Kaminari.paginate_array([]) if date.to_date < Date.current
+      return [] if date.to_date < Date.current
 
       result = direct_trips
       result += multi_leg_trips if result.empty? || result.size < 3 || ActiveModel::Type::Boolean.new.cast(@options[:include_multi_leg])
-      Kaminari.paginate_array(result)
+      preload_vehicle_type_assets(result)
+      paginate(result)
     end
 
     private
 
+    def paginate(result)
+      return result if options[:per_page].blank?
+
+      Kaminari.paginate_array(result).page(options[:page]).per(options[:per_page])
+    end
+
+    # The serializer reads each vehicle type's photos and option types; loading them once here avoids a pair of
+    # queries per distinct vehicle type.
+    def preload_vehicle_type_assets(result)
+      vehicle_types = result.flat_map(&:trips).filter_map(&:vehicle_type).uniq
+      return if vehicle_types.empty?
+
+      ActiveRecord::Associations::Preloader.new(records: vehicle_types, associations: %i[vehicle_photos option_types]).call
+    end
+
     def direct_trips
       SpreeCmCommissioner::SingleLegTripsQuery.new(
         origin_id: origin_id,

data/app/services/spree_cm_commissioner/api_caches/fetch_details.rb

@@ -0,0 +1,128 @@
+module SpreeCmCommissioner
+  module ApiCaches
+    # Everything the clear-cache dialog shows, for the Spree admin (spree/admin/api_caches/show) and
+    # the cm-market-server dashboard (shared_console/api_caches/show), which style it separately. Only called when the
+    # dialog opens, never on page render. Takes the same model/id/tenant as RequestClear.
+    #
+    # eg. FetchDetails.call(model: 'Spree::Product', id: 123)
+    #     => success(state: :edited, edited_at:, refresh_seconds:, sends_by:, sent_at:, cooldown_until:,
+    #                failure:, busy:, history:, patterns:)
+    #
+    # state, the dialog's headline, leans towards waiting since every clear is a paid CloudFront
+    # invalidation:
+    #   :queued      a clear someone asked for is waiting to be sent.
+    #   :pending     an automatic clear (queued on save, including a linked record's save) is waiting
+    #                for OrchestrateJob, which sends it by sends_by.
+    #   :edited      edited after the last sent clear, less than a CDN TTL ago: the app may still show
+    #                the old version.
+    #   :sent        a clear was sent after the last edit, within the last CDN TTL.
+    #   :up_to_date  otherwise: any copy cached before the last edit has expired or been cleared.
+    #
+    # cooldown_until is a CDN TTL after the last sent clear: edits made since then show in the app on
+    # their own by that time anyway, so RequestClear refuses another clear before it for callers
+    # asked to apply it (dashboard users who aren't admins).
+    class FetchDetails
+      prepend ::Spree::ServiceModule::Base
+
+      HISTORY_LIMIT = 5
+
+      # Clear-alls of every model share their storefront as maintainable (CacheInvalidation), so more
+      # are read than shown and the rest filtered by model.
+      CLEAR_ALL_SCAN_LIMIT = HISTORY_LIMIT * 4
+
+      # An automatic task is due 5 minutes after it was queued (MaintenanceTask.due_for_retry) and
+      # picked up by OrchestrateJob, scheduled every 5 minutes in cm-market-server's schedule.yml.
+      AUTOMATIC_SEND_WITHIN = 10.minutes
+
+      def call(model:, id: nil, tenant: nil)
+        maintainable = MaintenanceTasks::CacheInvalidation.maintainable_for(model: model, id: id, tenant: tenant)
+        return failure(nil, "#{[model, id].compact.join(' ')} cannot be cleared") if maintainable.nil?
+
+        model_class = Invalidate::SUPPORTED_MODELS[model]
+        tasks = MaintenanceTasks::CacheInvalidation.where(maintainable: maintainable).order(created_at: :desc)
+
+        if id.present?
+          tasks = tasks.limit(HISTORY_LIMIT).to_a
+          patterns = Invalidate.new.patterns_for(maintainable, model_class: model_class)
+          edited_at = maintainable.updated_at
+        else
+          tasks = tasks.limit(CLEAR_ALL_SCAN_LIMIT).select { |task| task.target_model == model }.first(HISTORY_LIMIT)
+          patterns = InvalidateAll.new.patterns_for(model, tenant: tenant)
+          edited_at = InvalidateAll.new.records_scope(model_class, tenant).maximum(:updated_at)
+        end
+
+        success(**headline(tasks, edited_at), history: history(tasks), patterns: patterns)
+      end
+
+      private
+
+      def headline(tasks, edited_at)
+        latest = tasks.first
+        ttl = ContentCachable.cdn_max_age(:fresh)
+        sent = tasks.find { |task| task.clear_status == :sent }
+        pending = latest if automatic_pending?(latest)
+        cooldown_until = sent && (sent.completed_at + ttl)
+
+        {
+          state: state_for(latest, pending, edited_at, sent, ttl),
+          edited_at: edited_at,
+          refresh_seconds: ttl,
+          sends_by: pending && (pending.updated_at + AUTOMATIC_SEND_WITHIN),
+          sent_at: sent&.completed_at,
+          cooldown_until: (cooldown_until if cooldown_until&.future?),
+          failure: failure_of(latest),
+          busy: busy?(latest)
+        }
+      end
+
+      def state_for(latest, pending, edited_at, sent, ttl)
+        return :pending if pending
+        return :queued if latest&.clear_status == :queued
+
+        freshness_state(edited_at, sent, ttl)
+      end
+
+      def freshness_state(edited_at, sent, ttl)
+        # The task touched the record before sending, so an edit it covers has updated_at <= the
+        # task's completed_at.
+        covered = sent.present? && (edited_at.nil? || edited_at <= sent.completed_at)
+        return :edited if edited_at.present? && !covered && edited_at > ttl.seconds.ago
+        return :sent if covered && sent.completed_at > ttl.seconds.ago
+
+        :up_to_date
+      end
+
+      # A save queued it and nobody has clicked since. With automatic invalidation switched off it
+      # would only be skipped, so it promises nothing.
+      def automatic_pending?(task)
+        task&.clear_status == :queued && !task.manually_triggered? && ENV['CACHE_AUTO_INVALIDATION_DISABLED'] != 'yes'
+      end
+
+      # A clear someone asked for, which another click would only reuse. An automatic one waiting for
+      # OrchestrateJob, or a queued one that already failed once, is sent now by a click.
+      def busy?(latest)
+        latest&.clear_status == :queued && latest.manually_triggered? && latest.last_error.blank?
+      end
+
+      # Why the latest clear didn't (or hasn't yet) gone through.
+      def failure_of(task)
+        task.last_error.presence if %i[failed queued].include?(task&.clear_status)
+      end
+
+      def history(tasks)
+        users = Spree.user_class.where(id: tasks.filter_map(&:triggered_by_id).uniq).index_by(&:id)
+
+        tasks.map do |task|
+          { at: task.created_at, by: triggered_by_name(task, users), status: task.clear_status, error: failure_of(task) }
+        end
+      end
+
+      def triggered_by_name(task, users)
+        scope = 'spree_cm_commissioner.api_caches.details'
+        return I18n.t('automatic', scope: scope) unless task.manually_triggered?
+
+        users[task.triggered_by_id]&.display_name.presence || I18n.t('unknown_user', scope: scope)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/api_caches/invalidate.rb

@@ -1,9 +1,17 @@
 module SpreeCmCommissioner
   module ApiCaches
-    # Clears one record's cached API responses. Every record of a model goes through InvalidateAll.
+    # Refreshes one record's Rails cache keys and returns the CloudFront paths that serve it, which
+    # MaintenanceTasks::CacheInvalidation sends. Every record of a model goes through InvalidateAll.
+    #
+    # Only the record's own storefront is cleared, as InvalidateAll does: its tenant's API
+    # (/api/v2/tenant/ paths) when it belongs to a tenant, the BookMe+ storefront otherwise. Each path
+    # is billed, and the other storefront's copy, if anything ever fetched one, expires within a CDN
+    # TTL anyway.
     class Invalidate
       prepend ::Spree::ServiceModule::Base
 
+      TENANT_PREFIX = '/api/v2/tenant/'.freeze
+
       SUPPORTED_MODELS = {
         'SpreeCmCommissioner::HomepageSection' => SpreeCmCommissioner::HomepageSection,
         'SpreeCmCommissioner::HomepageBackground' => SpreeCmCommissioner::HomepageBackground,
@@ -27,11 +35,11 @@ module SpreeCmCommissioner
 
       HOMEPAGE_BACKGROUND_PATTERNS = ['/api/v2/storefront/homepage*'].freeze
 
-      # Deliberately broad, and identical for single-record and all-record
-      # invalidation: a payment method is either vendor-owned or store-level, and a
-      # store-level one is served for every vendor through the fallback in
-      # SpreeCmCommissioner::PaymentMethods::Find. From the record alone we cannot
-      # tell which vendors are affected.
+      # Deliberately broad, identical for single-record and all-record invalidation, and the one
+      # model not scoped to the record's storefront: a payment method is either vendor-owned or
+      # store-level, and a store-level one is served for every vendor, tenants included, through the
+      # fallback in SpreeCmCommissioner::PaymentMethods::Find. From the record alone we cannot tell
+      # which vendors are affected.
       #
       # vendor_id is a query param, so the trailing `*` is what clears every
       # vendor's cached variant of this path in one go.
@@ -61,19 +69,33 @@ module SpreeCmCommissioner
 
         refresh_record_cache_key(record)
 
+        success(record: record, api_patterns: patterns_for(record, model_class: model_class))
+      end
+
+      # Side-effect free, so the clear-cache dialog can show what a clear would send. Empty when the
+      # record's storefront has no API for it, e.g. a show of a vendor without a tenant.
+      # eg. patterns_for(product) => ['/api/v2/storefront/products/123*', '/api/v2/storefront/products/slug-of-product*']
+      def patterns_for(record, model_class: record.class)
         # The record's own class first (a Show found as a Spree::Taxon keeps its show paths), then the
         # model asked for, since STI subclasses such as Spree::Gateway::Payway have no entry of their own.
         patterns = single_api_pattern[record.class.name] || single_api_pattern[model_class.name]
-        api_patterns = patterns.map do |pattern|
+        return patterns if patterns.equal?(PAYMENT_METHOD_PATTERNS)
+
+        tenant = tenant_of(record)
+        patterns.select { |pattern| pattern.start_with?(TENANT_PREFIX) == tenant.present? }.map do |pattern|
           pattern.gsub(/:(\w+)/) do
             key = Regexp.last_match(1)
             record.public_send(key).to_s
           end
         end
+      end
 
-        enqueue_invalidate(api_patterns)
+      # A product, vendor or homepage section has its own tenant; a taxon, show or voting session has
+      # its vendor's. Menus, seat layouts and homepage backgrounds are BookMe+ only.
+      def tenant_of(record)
+        return record.tenant if record.respond_to?(:tenant)
 
-        success(record: record, api_patterns: api_patterns)
+        record.vendor&.tenant if record.respond_to?(:vendor)
       end
 
       def single_api_pattern
@@ -117,11 +139,6 @@ module SpreeCmCommissioner
         record.touch
         # rubocop:enable Rails/SkipsModelValidations
       end
-
-      # Enqueue cache invalidation jobs
-      def enqueue_invalidate(patterns)
-        SpreeCmCommissioner::InvalidateCacheRequestJob.perform_later(patterns: patterns)
-      end
     end
   end
 end

data/app/services/spree_cm_commissioner/api_caches/invalidate_all.rb

@@ -1,8 +1,10 @@
 module SpreeCmCommissioner
   module ApiCaches
-    # Clears every record of a model for one storefront. `tenant` is required so a clear-all never
-    # pays for both namespaces by accident: nil is the BookMe+ storefront (/api/v2/storefront/
-    # paths), a SpreeCmCommissioner::Tenant is that tenant's API (/api/v2/tenant/ paths).
+    # Refreshes every record of a model for one storefront and returns the CloudFront paths that
+    # serve them, which MaintenanceTasks::CacheInvalidation sends, as for Invalidate. `tenant` is
+    # required so a clear-all never pays for both namespaces by accident: nil is the BookMe+
+    # storefront (/api/v2/storefront/ paths), a SpreeCmCommissioner::Tenant is that tenant's API
+    # (/api/v2/tenant/ paths).
     #
     # Tenant APIs take the tenant from the OAuth token, not the URL, so every tenant shares one path
     # today; taking the record keeps callers the same if tenant paths ever carry it.
@@ -11,8 +13,6 @@ module SpreeCmCommissioner
     class InvalidateAll
       prepend ::Spree::ServiceModule::Base
 
-      TENANT_PREFIX = '/api/v2/tenant/'.freeze
-
       API_PATTERNS = {
         'SpreeCmCommissioner::HomepageSection' => Invalidate::HOMEPAGE_SECTION_PATTERNS,
         'SpreeCmCommissioner::HomepageBackground' => Invalidate::HOMEPAGE_BACKGROUND_PATTERNS,
@@ -36,25 +36,22 @@ module SpreeCmCommissioner
         return failure(nil, 'Model is not supported') if model_class.nil?
         return failure(nil, 'tenant must be a SpreeCmCommissioner::Tenant or nil') unless tenant.nil? || tenant.is_a?(SpreeCmCommissioner::Tenant)
 
-        refresh_records_cache_key(model_class, tenant)
-
-        api_patterns = API_PATTERNS[model].select { |pattern| pattern.start_with?(TENANT_PREFIX) == tenant.present? }
-
-        # Empty when the model has no API in this namespace, e.g. homepage backgrounds for a tenant,
-        # and CloudFront rejects an empty batch.
-        SpreeCmCommissioner::InvalidateCacheRequestJob.perform_later(patterns: api_patterns) if api_patterns.any?
+        records_scope(model_class, tenant).find_each(&:touch)
 
-        success(api_patterns: api_patterns)
+        # Empty when the model has no API in this namespace, e.g. homepage backgrounds for a tenant.
+        success(api_patterns: patterns_for(model, tenant: tenant))
       end
 
-      private
+      # Side-effect free, so the clear-cache dialog can show what a clear would send.
+      def patterns_for(model, tenant:)
+        API_PATTERNS.fetch(model, []).select { |pattern| pattern.start_with?(Invalidate::TENANT_PREFIX) == tenant.present? }
+      end
 
       # updated_at keys Spree's serializer and collection caches, so only this storefront's records
-      # are touched when the model is tenant-scoped.
-      def refresh_records_cache_key(model_class, tenant)
-        scope = model_class.column_names.include?('tenant_id') ? model_class.where(tenant_id: tenant&.id) : model_class.all
-
-        scope.find_each(&:touch)
+      # are touched when the model is tenant-scoped. Also where the clear-cache dialog reads the last
+      # edit from.
+      def records_scope(model_class, tenant)
+        model_class.column_names.include?('tenant_id') ? model_class.where(tenant_id: tenant&.id) : model_class.all
       end
     end
   end

data/app/services/spree_cm_commissioner/api_caches/request_clear.rb

@@ -0,0 +1,71 @@
+module SpreeCmCommissioner
+  module ApiCaches
+    # What a clear-cache button calls. It records the click as a CacheInvalidation task and enqueues
+    # it, so the click returns at once and shows in the record's history (FetchDetails).
+    #
+    # Without id it clears every record of model on one storefront, as InvalidateAll: tenant for that
+    # tenant's API, nil for the BookMe+ storefront.
+    #
+    # cooldown: refuses a clear within a CDN TTL of the last one sent (FetchDetails#cooldown_until),
+    # for callers that limit how often their users pay for one.
+    #
+    # eg. RequestClear.call(model: 'Spree::Product', id: 123, user: current_user)
+    #     RequestClear.call(model: 'SpreeCmCommissioner::HomepageSection', tenant: tenant, user: current_user, cooldown: true)
+    class RequestClear
+      prepend ::Spree::ServiceModule::Base
+
+      def call(model:, user:, id: nil, tenant: nil, cooldown: false)
+        maintainable = MaintenanceTasks::CacheInvalidation.maintainable_for(model: model, id: id, tenant: tenant)
+        return failure(nil, "#{[model, id].compact.join(' ')} cannot be cleared") if maintainable.nil?
+
+        cooldown_until = cooldown && FetchDetails.call(model: model, id: id, tenant: tenant).value[:cooldown_until]
+        return failure(nil, I18n.t('spree_cm_commissioner.api_caches.cooldown', time: I18n.l(cooldown_until, format: '%H:%M'))) if cooldown_until
+
+        task = find_or_create_task(maintainable, model: model, user: user)
+        return failure(nil, I18n.t('spree_cm_commissioner.api_caches.another_clear_in_progress')) if task.target_model != model
+
+        task.async_execute
+        success(task: task)
+      end
+
+      private
+
+      # index_unique_pending_maintenance_tasks allows one pending task per maintainable, which is also
+      # what stops a double click from paying twice: the second click reuses the first one's task.
+      def find_or_create_task(maintainable, model:, user:)
+        task = pending_task(maintainable)
+        return reuse(task, model, user) if task.present?
+
+        MaintenanceTasks::CacheInvalidation.create!(
+          maintainable: maintainable,
+          manually_triggered: true,
+          triggered_by_id: user&.id,
+          invalidation_model: model
+        )
+      rescue ActiveRecord::RecordNotUnique
+        reuse(pending_task(maintainable), model, user)
+      end
+
+      def pending_task(maintainable)
+        MaintenanceTasks::CacheInvalidation.pending.find_by(maintainable: maintainable)
+      end
+
+      # A pending task is either an automatic one still waiting for OrchestrateJob, which the click
+      # sends now and takes credit for, or a clear-all of the same storefront. One for another model
+      # is left alone, and the caller reports it is busy.
+      def reuse(task, model, user)
+        return task if task.invalidate_all? && task.target_model != model
+
+        task.update!(
+          manually_triggered: true,
+          triggered_by_id: user&.id || task.triggered_by_id,
+          invalidation_model: model,
+          attempt_count: 0,
+          last_error: nil
+        )
+
+        task
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/guests/claim_invite_guest_service.rb

@@ -44,8 +44,10 @@ module SpreeCmCommissioner
 
       # Telegram Alert
       def send_claim_alert(guest, order)
-        vendor = guest.event&.vendor
-        return unless vendor&.preferred_telegram_chat_id
+        chat_id = guest.event&.telegram_alert_chat_id || guest.event&.vendor&.preferred_telegram_chat_id
+        return if chat_id.blank?
+
+        vendor = guest.event.vendor
 
         factory = SpreeCmCommissioner::InviteGuestClaimedTelegramMessageFactory.new(
           title: '📣 --- [NEW GUEST CLAIMED INVITATION] ---',
@@ -55,7 +57,7 @@ module SpreeCmCommissioner
         )
 
         SpreeCmCommissioner::TelegramNotificationSenderJob.perform_later(
-          chat_id: vendor.preferred_telegram_chat_id,
+          chat_id: chat_id,
           message: factory.message,
           parse_mode: factory.parse_mode
         )