spree_cm_commissioner 2.8.1.pre.pre.1 → 2.8.1.pre.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19fd000fa15ceffed974595795de236e66b34973806086d138bc5867183bc9c0
-  data.tar.gz: e9cc2d23feeb9fd6b66384c3b3e2febeadc51ecfac906a3e546613578db19156
+  metadata.gz: 8250d9a96dcceb058991c416ad4b91380fa42f5d43e301c366e74bfe9eb0e27b
+  data.tar.gz: a8c9301047c15f6ef760bdda1cc9087ac4f7a3539cd6aa86b43a99ab97fc6f16
 SHA512:
-  metadata.gz: 87e417d02f3082ee1ec8905db14343bfe33309f2d7b4b04274c7abf2f86e22cb8998374bc34c64361632afdff581198a725d281c8c0f2b2bbe0ce91419a7a1cc
-  data.tar.gz: 75e78fd7b59fc796318dc24a70483fb51ab8ade2dc6df5714bdf2c6266d2055d8438679e6edf6d5089d8382501f8dc52d0d8684334f4c73e6a92820db6c6f110
+  metadata.gz: 87bba18fe41a801abf62fc7a83c444452f5b3780b23edaa44bbf86b98271b06877bc8c52bddfc5761b5fdee5953226201c52556cfba30405c1e1f95af2067861
+  data.tar.gz: 2a7fd81827d6be81291146d17f46ff54a61a59aa4194a552f89ccc59463dc93a4ccc742c0534fd5c18354136314b2e9db571e97b6e8822fff3bbc6c116f3114d

data/.env.example

@@ -50,3 +50,15 @@ EXPORT_PRESIGNED_URL_EXPIRATION_MINUTES=15
 
 # import order batch size
 IMPORT_ORDERS_BATCH_SIZE=50
+
+# Inventory Hold System
+# See: app/services/spree_cm_commissioner/order_holds/hold.rb
+HOLD_DURATION_IN_MINUTES=8                  # How long a hold is active after checkout begins (address step)
+
+# See: app/services/spree_cm_commissioner/order_holds/lock_for_payment.rb
+PAYMENT_LOCK_MIN_DURATION_IN_MINUTES=5      # Minimum remaining hold time required when entering the payment step; hold is extended if below this threshold
+
+# See: app/services/spree_cm_commissioner/inventory_holds/validate_limits.rb
+MAX_ACTIVE_HOLDS_PER_USER=3                 # Max concurrent active holds allowed per user across all orders
+MAX_HOLDS_PER_IP_PER_HOUR=5                 # Max hold attempts per IP address within a rolling 1-hour window (abuse prevention)
+HOLD_COOLDOWN_AFTER_EXPIRY_IN_MINUTES=2     # Cooldown period before a user can re-acquire a hold after one expired on them

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.8.1.pre.pre.1)
+    spree_cm_commissioner (2.8.1.pre.3)
       activerecord-multi-tenant
       activerecord_json_validator (~> 2.1, >= 2.1.3)
       aws-sdk-cloudfront

data/app/controllers/concerns/spree_cm_commissioner/order_concern.rb

@@ -11,6 +11,7 @@ module SpreeCmCommissioner
         raise CanCan::AccessDenied
       end
 
+      @spree_current_order.last_ip_address = request.remote_ip
       @spree_current_order
     end
 

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

@@ -5,7 +5,7 @@ module Spree
 
       def recalculate_conversions
         if @taxon.parent.event?
-          SpreeCmCommissioner::MaintenanceTasks::Event.pending.find_or_create_by(
+          SpreeCmCommissioner::MaintenanceTasks::Event.pending.create_or_find_by(
             maintainable_type: 'Spree::Taxon',
             maintainable_id: @taxon.parent.id
           ) do |task|

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

@@ -0,0 +1,135 @@
+# rubocop:disable Rails/I18nLocaleTexts
+module Spree
+  module Admin
+    class FeaturedTripsController < BaseController
+      before_action :require_taxon_manager
+
+      def index
+        @status = filter_status
+        @query = params[:q].to_s.strip
+        @vendor_id = params[:vendor_id].presence
+        @origin_place_id = params[:origin_place_id].presence
+        @destination_place_id = params[:destination_place_id].presence
+        @vendors = Spree::Vendor.order(:name)
+        @places = SpreeCmCommissioner::Place.order(:name)
+        @active_count = SpreeCmCommissioner::Trip.currently_featured.count
+        @expired_count = SpreeCmCommissioner::Trip.where.not(featured_until: nil).where('featured_until < ?', Time.current).count
+        @featured_trips = filtered_featured_trips
+        @available_trips = available_trips
+      end
+
+      def create
+        trip = SpreeCmCommissioner::Trip.find(params[:trip_id])
+        featured_until = parse_featured_until(params[:featured_until])
+
+        if featured_until.present? && featured_until > Time.current && trip.update(featured_until: featured_until)
+          flash[:success] = 'Trip was added to featured trips.'
+        else
+          flash[:error] = 'Featured until must be a future date and time.'
+        end
+
+        redirect_to spree.admin_featured_trips_path
+      end
+
+      def update
+        trip = SpreeCmCommissioner::Trip.find(params[:id])
+
+        if ActiveModel::Type::Boolean.new.cast(params[:remove])
+          trip.update(featured_until: nil)
+          flash[:success] = 'Trip was removed from featured trips.'
+        else
+          update_featured_until(trip)
+        end
+
+        redirect_to spree.admin_featured_trips_path(
+          status: params[:status],
+          vendor_id: params[:vendor_id],
+          origin_place_id: params[:origin_place_id],
+          destination_place_id: params[:destination_place_id],
+          q: params[:q]
+        )
+      end
+
+      private
+
+      def require_taxon_manager
+        return if can?(:manage, Spree::Taxon)
+
+        flash[:error] = 'You are not authorized to access this page.'
+        redirect_to spree.admin_promotions_path
+      end
+
+      def update_featured_until(trip)
+        featured_until = parse_featured_until(params[:featured_until])
+
+        if featured_until.present? && featured_until > Time.current && trip.update(featured_until: featured_until)
+          flash[:success] = 'Featured trip was updated.'
+        else
+          flash[:error] = 'Featured until must be a future date and time.'
+        end
+      end
+
+      def filtered_featured_trips
+        scope = SpreeCmCommissioner::Trip.includes(:vendor, :product, :origin_place, :destination_place, :vehicle_type)
+                                         .where.not(featured_until: nil)
+        scope = apply_status_filter(scope)
+        scope = apply_place_filter(scope)
+        scope = apply_vendor_filter(scope)
+        scope = apply_text_filter(scope)
+        scope.order(featured_until: :asc, departure_time: :asc).page(params[:page]).per(50)
+      end
+
+      def available_trips
+        scope = SpreeCmCommissioner::Trip.includes(:vendor, :product, :origin_place, :destination_place, :vehicle_type)
+                                         .not_currently_featured
+        scope = apply_place_filter(scope)
+        scope = apply_vendor_filter(scope)
+        scope = apply_text_filter(scope)
+        scope.order(departure_time: :desc).limit(200)
+      end
+
+      def apply_status_filter(scope)
+        case @status
+        when 'expired'
+          scope.where('cm_trips.featured_until < ?', Time.current)
+        when 'all'
+          scope
+        else
+          scope.currently_featured
+        end
+      end
+
+      def apply_vendor_filter(scope)
+        return scope if @vendor_id.blank?
+
+        scope.where(vendor_id: @vendor_id)
+      end
+
+      def apply_place_filter(scope)
+        scope = scope.where(origin_place_id: @origin_place_id) if @origin_place_id.present?
+        scope = scope.where(destination_place_id: @destination_place_id) if @destination_place_id.present?
+        scope
+      end
+
+      def apply_text_filter(scope)
+        return scope if @query.blank?
+
+        scope.left_joins(:product, :vendor)
+             .where('spree_products.name ILIKE :query OR spree_vendors.name ILIKE :query', query: "%#{@query}%")
+      end
+
+      def filter_status
+        %w[active expired all].include?(params[:status]) ? params[:status] : 'active'
+      end
+
+      def parse_featured_until(value)
+        return if value.blank?
+
+        Time.zone.parse(value.to_s)
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+  end
+end
+# rubocop:enable Rails/I18nLocaleTexts

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

@@ -0,0 +1,64 @@
+module Spree
+  module Admin
+    class InventoryHoldsController < BaseController
+      def index
+        authorize! :manage, SpreeCmCommissioner::InventoryHold
+
+        q = params.fetch(:q, {})
+        q = q.respond_to?(:to_unsafe_h) ? q.to_unsafe_h.deep_dup : q.deep_dup
+        q['s'] ||= 'created_at desc'
+        q['created_at_gt'] = parse_time_or_nil(q['created_at_gt'], :beginning_of_day) if q['created_at_gt'].present?
+        q['created_at_lt'] = parse_time_or_nil(q['created_at_lt'], :end_of_day) if q['created_at_lt'].present?
+
+        @search = scope.ransack(q)
+        result_scope = @search.result(distinct: true)
+
+        @holds = result_scope
+                 .includes(order: [:user, { line_items: { variant: { product: :vendor } } }])
+                 .page(params[:page])
+                 .per(params[:per_page] || Spree::Backend::Config[:admin_orders_per_page])
+
+        @status_counts = result_scope.reorder(nil).group(:status).count
+      end
+
+      def release
+        authorize! :manage, SpreeCmCommissioner::InventoryHold
+
+        hold = SpreeCmCommissioner::InventoryHold.find(params[:id])
+
+        if hold.finalized?
+          flash[:error] = "Hold ##{hold.id} is already #{hold.status} and cannot be released."
+          return redirect_to admin_inventory_holds_path(back_params)
+        end
+
+        result = SpreeCmCommissioner::InventoryHolds::Release.call(hold: hold, reason: :user_canceled)
+
+        if result.success?
+          flash[:success] = "Hold ##{hold.id} for order #{hold.order.number} has been released."
+        else
+          flash[:error] = "Failed to release hold ##{hold.id}: #{result.error}"
+        end
+
+        redirect_to admin_inventory_holds_path(back_params)
+      end
+
+      private
+
+      def back_params
+        raw_params = params[:back_params].presence || params
+        ActionController::Parameters.new(raw_params).permit(:page, :per_page, q: {})
+      end
+
+      def scope
+        SpreeCmCommissioner::InventoryHold
+          .accessible_by(current_ability, :manage)
+      end
+
+      def parse_time_or_nil(value, boundary)
+        Time.zone.parse(value).public_send(boundary)
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

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

@@ -5,19 +5,20 @@ module Spree
         authorize! :manage, SpreeCmCommissioner::InventoryItem
 
         @time_range = params[:time_range] || 7
-        @filter_type = params[:filter_type] || 'all'
+        @product_type = params[:product_type].presence
         @vendor_id = params[:vendor_id]
 
         finder = SpreeCmCommissioner::InventoryItems::RecentlyChangedFinder.new(
           time_range: @time_range.to_i.days.ago,
           limit: 1000,
           vendor_id: @vendor_id,
-          filter_type: @filter_type
+          product_type: @product_type
         )
 
         @inventory_items = finder.execute
         @total_count = @inventory_items.size
         @out_of_sync_count = @inventory_items.count { |item| item[:out_of_sync] }
+        @on_hold_out_of_sync_count = @inventory_items.count { |item| item[:on_hold_out_of_sync] }
       end
 
       def reset
@@ -32,7 +33,10 @@ module Spree
           flash[:error] = "Failed to reset inventory: #{result.message}"
         end
 
-        redirect_to action: :index, time_range: params[:time_range], filter_type: params[:filter_type]
+        redirect_to action: :index,
+                    time_range: params[:time_range],
+                    product_type: params[:product_type],
+                    vendor_id: params[:vendor_id]
       end
     end
   end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Admin
+    class OauthApplicationsController < Spree::Admin::ResourceController
+      # Override default scopes behavior - only auto-assign 'admin' scope for new applications
+      # Edit forms allow users to modify scopes without forced default
+      before_action :set_default_scopes, only: [:new]
+
+      private
+
+      def create_turbo_stream_enabled?
+        true
+      end
+
+      def set_default_scopes
+        @object.scopes = 'admin' if @object.scopes.blank?
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Spree
 
       before_action :load_parent
 
-      helper_method :inventory_item_message
+      helper_method :inventory_item_message, :inventory_item_hold_message
 
       def load_parent
         @product = Spree::Product.find_by(slug: params[:product_id])
@@ -75,6 +75,15 @@ module Spree
         end
       end
 
+      def inventory_item_hold_message(inventory_item, cached_inventory_item)
+        synced = inventory_item.quantity_on_hold == cached_inventory_item.quantity_on_hold
+        if synced
+          "Synced: Quantity on hold matches in both DB and Redis (#{cached_inventory_item.quantity_on_hold})."
+        else
+          "Out of sync: Redis shows #{cached_inventory_item.quantity_on_hold} on hold, which doesn't match the database."
+        end
+      end
+
       private
 
       def load_inventories

data/app/controllers/spree/api/v2/operator/recalculate_tickets_controller.rb

@@ -7,7 +7,7 @@ module Spree
           before_action :load_taxon, only: :create
 
           def create
-            SpreeCmCommissioner::MaintenanceTasks::Event.pending.find_or_create_by(
+            SpreeCmCommissioner::MaintenanceTasks::Event.pending.create_or_find_by(
               maintainable: @taxon
             ).async_execute
 

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

@@ -0,0 +1,54 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class PricingPreviewsController < ::Spree::Api::V2::BaseController
+          # GET /api/v2/tenant/pricing_previews
+          def index
+            permitted_preview_params = params.permit(SpreeCmCommissioner::PricingModels::OrderContext::PREVIEW_PERMITTED_PARAMS)
+            order_context = SpreeCmCommissioner::PricingModels::OrderContext.load!(permitted_preview_params[:order_context])
+            pricing_models_updated_at = SpreeCmCommissioner::PricingModel.joins(:vendor)
+                                                                         .where(spree_vendors: { tenant_id: nil })
+                                                                         .maximum(:updated_at)
+            cache_key = 'pricing:preview:v2:' \
+                        "#{Digest::SHA256.hexdigest(permitted_preview_params.to_json)}:" \
+                        "#{pricing_models_updated_at.to_i}"
+
+            cached_result = Rails.cache.fetch(cache_key, expires_in: 60.seconds) do
+              result = SpreeCmCommissioner::PricingModels::Preview.call(order_context: order_context)
+              if result.success?
+                {
+                  success: true,
+                  payload: serialize_resource(result.value[:pricing_preview]).as_json
+                }
+              else
+                {
+                  success: false,
+                  error: result.error.to_s
+                }
+              end
+            end
+
+            if cached_result[:success]
+              render_serialized_payload { cached_result[:payload] }
+            else
+              render_error_payload(cached_result[:error], 422)
+            end
+          rescue ArgumentError => e
+            render_error_payload(e.message, 422)
+          end
+
+          # override
+          def default_resource_includes
+            ['pricing_adjustments']
+          end
+
+          # override
+          def resource_serializer
+            SpreeCmCommissioner::V2::Storefront::PricingPreviewSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/storefront/transit/item_availabilities_controller.rb

@@ -0,0 +1,66 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        module Transit
+          class ItemAvailabilitiesController < ::Spree::Api::V2::ResourceController
+            include SpreeCmCommissioner::Integrations::InventorySyncCachable
+
+            def create
+              sync_result = sync_item_availability!
+
+              unless sync_result.success?
+                error_message = sync_result.to_h.dig(:error, :message) || 'Sync failed'
+                return render_error_payload(error_message, 422)
+              end
+
+              item_availability = SpreeCmCommissioner::ItemAvailabilitySync.new(
+                id: trip.id,
+                last_sync_at: sync_result.last_synced_at
+              )
+              render_serialized_payload { serialize_resource(item_availability) }
+            rescue ActiveRecord::RecordNotFound => e
+              render_error_payload(e.message, 404)
+            end
+
+            private
+
+            def trip
+              @trip ||= SpreeCmCommissioner::Trip.find(params[:trip_id])
+            end
+
+            def integration
+              @integration ||= trip.vendor&.integration
+            end
+
+            def sync_item_availability!
+              # Return success result if vendor has no integration
+              return SpreeCmCommissioner::Integrations::Base::SyncResult.new if integration.nil?
+
+              # Check cache first for successful results only
+              cached_result = Rails.cache.read(sync_cache_key)
+              return cached_result if cached_result
+
+              # Perform sync
+              result = integration.sync_item_availability!(trip_id: trip.id, on_date: params[:on_date])
+
+              # Only cache successful results to avoid sticky failures
+              Rails.cache.write(sync_cache_key, result, expires_in: sync_cache_ttl) if result.success?
+
+              result
+            end
+
+            def sync_cache_key
+              # Include trip.updated_at to auto-bust cache when trip is updated by background syncs
+              "item_availability_syncs:#{trip.id}:#{params[:on_date]}:#{trip.updated_at.to_i}"
+            end
+
+            def resource_serializer
+              SpreeCmCommissioner::V2::Storefront::ItemAvailabilitySyncSerializer
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -39,6 +39,7 @@ module Spree
               params[:date],
               params[:route_type],
               params[:vendor_id],
+              params[:featured],
               params[:number_of_guests],
               resource_includes&.sort&.join(','),
               sparse_fields&.sort&.join(','),

data/app/controllers/spree/api/v2/tenant/intercity_taxi/draft_orders_controller.rb

@@ -29,6 +29,7 @@ module Spree
               result = SpreeCmCommissioner::IntercityTaxiOrder::Update.call(
                 order: spree_current_order,
                 remark: params[:remark],
+                passenger_count: params[:passenger_count],
                 pickup_map_place_attributes: params[:pickup_map_place_attributes]&.permit(
                   :place_name,
                   :lat,

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

@@ -0,0 +1,60 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class PricingPreviewsController < BaseController
+          # GET /api/v2/tenant/pricing_previews
+          def index
+            permitted_preview_params = params.permit(SpreeCmCommissioner::PricingModels::OrderContext::PREVIEW_PERMITTED_PARAMS)
+            order_context = SpreeCmCommissioner::PricingModels::OrderContext.load!(
+              permitted_preview_params[:order_context]&.merge(tenant_id: current_tenant.id)
+            )
+
+            pricing_models_updated_at = SpreeCmCommissioner::PricingModel.joins(:vendor)
+                                                                         .where(spree_vendors: { tenant_id: current_tenant.id })
+                                                                         .maximum(:updated_at)
+            cache_key = 'pricing:preview:v2:' \
+                        "#{Digest::SHA256.hexdigest(permitted_preview_params.to_json)}:" \
+                        "#{pricing_models_updated_at.to_i}"
+
+            cached_result = Rails.cache.fetch(cache_key, expires_in: 60.seconds) do
+              result = SpreeCmCommissioner::PricingModels::Preview.call(order_context: order_context)
+
+              if result.success?
+                {
+                  success: true,
+                  payload: serialize_resource(result.value[:pricing_preview]).as_json
+                }
+              else
+                {
+                  success: false,
+                  error: result.error.to_s
+                }
+              end
+            end
+
+            if cached_result[:success]
+              render_serialized_payload { cached_result[:payload] }
+            else
+              render_error_payload(cached_result[:error], 422)
+            end
+          rescue ArgumentError => e
+            render_error_payload(e.message, 422)
+          end
+
+          private
+
+          # override
+          def default_resource_includes
+            ['pricing_adjustments']
+          end
+
+          # override
+          def resource_serializer
+            Spree::V2::Tenant::PricingPreviewSerializer
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -23,13 +23,13 @@ module Spree
               vendor_id: current_vendor.id
             )
 
-            result = SpreeCmCommissioner::VoteProcessor.new(
+            result = SpreeCmCommissioner::VoteProcessor.call(
               voting_session: voting_session,
               contestant: contestant,
               user: spree_current_user,
               params: processor_params,
               request: request
-            ).call
+            )
 
             if result.success?
               render_serialized_payload(201) { serialize_resource(result.value) }

data/app/factory/spree_cm_commissioner/order_telegram_message_factory.rb

@@ -48,6 +48,8 @@ module SpreeCmCommissioner
     end
 
     def line_item_content(line_item)
+      return intercity_taxi_line_item_content(line_item) if intercity_taxi?(line_item)
+
       text = []
 
       text << bold(line_item.product.name.to_s)
@@ -82,6 +84,8 @@ module SpreeCmCommissioner
       text << "Email: #{inline_code(order.email)}" if order.email.present?
       text << "Delivery Address: #{formatted_shipping_address.presence || 'N/A'}" if order.delivery_required?
 
+      append_intercity_taxi_footer(text) if intercity_taxi_order?
+
       if show_details_link && order.guests.any?
         text << ''
         text << 'View Tickets:'
@@ -125,5 +129,89 @@ module SpreeCmCommissioner
 
       formatted_rows
     end
+
+    private
+
+    def intercity_taxi?(line_item)
+      trip_for(line_item)&.intercity_taxi?
+    end
+
+    def intercity_taxi_order?
+      selected_line_items.any? { |li| intercity_taxi?(li) }
+    end
+
+    def trip_for(line_item)
+      return nil unless line_item.respond_to?(:trip_id) && line_item.trip_id.present?
+
+      @trip_cache ||= {}
+      @trip_cache[line_item.trip_id] ||= SpreeCmCommissioner::Trip.find_by(id: line_item.trip_id)
+    end
+
+    def intercity_taxi_line_item_content(line_item)
+      text = []
+      route_text = taxi_route_text(line_item)
+      departure_text = taxi_departure_text(line_item)
+      text << bold('🚗 Trip Details')
+      text << "Route: #{route_text}" if route_text.present?
+      text << "Passengers: #{line_item.passenger_count || line_item.quantity}"
+      text << "Departure: #{departure_text}" if departure_text.present?
+
+      text.compact.join("\n")
+    end
+
+    def taxi_route_text(line_item)
+      trip = trip_for(line_item)
+      return line_item.product.name if trip.blank?
+
+      origin = trip.origin_place&.name
+      destination = trip.destination_place&.name
+      vehicle = trip.vehicle_type&.name
+
+      parts = [origin, destination].compact_blank.join(' → ')
+      vehicle.present? ? "#{parts} (#{vehicle})" : parts
+    end
+
+    def taxi_departure_text(line_item)
+      return nil unless line_item.date_present?
+
+      line_item.from_date.strftime('%b %d, %Y · %H:%M')
+    end
+
+    def nationality_text
+      values = order.saved_guests.map { |sg| sg.nationality&.name.presence || sg.nationality_group&.humanize }.compact.uniq
+      return nil if values.empty?
+
+      values.join(', ')
+    end
+
+    def append_intercity_taxi_footer(text)
+      text << "Nationality: #{nationality_text}" if nationality_text.present?
+
+      pickup = selected_line_items.filter_map(&:pickup_map_place).first
+      dropoff = selected_line_items.filter_map(&:dropoff_map_place).first
+
+      append_map_place(text, '📍 Pick-up Location', pickup) if pickup
+      append_map_place(text, '📍 Drop-off Location', dropoff) if dropoff
+
+      remark = selected_line_items.filter_map { |li| li.remark.presence }.first
+      return if remark.blank?
+
+      text << ''
+      text << bold('🗒️ Notes to Driver')
+      text << ERB::Util.html_escape(remark)
+    end
+
+    def append_map_place(text, title, map_place)
+      text << ''
+      text << bold(title)
+      text << "Address: #{ERB::Util.html_escape(map_place.place_name)}" if map_place.place_name.present?
+      text << "Google Maps: #{ERB::Util.html_escape(google_maps_link(map_place))}" if google_maps_link(map_place).present?
+    end
+
+    def google_maps_link(map_place)
+      return nil if map_place.lat.blank? || map_place.lng.blank?
+
+      "https://www.google.com/maps/search/?api=1&query=#{map_place.lat},#{map_place.lng}"
+    end
   end
 end