spree_razorpay_checkout 0.1.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fa91a572f8ba303d47dd90b0142eff75dc21478b85c9d85a9d2ca842318a4b9
-  data.tar.gz: 889b39cf1a9076a0b88d6d9a08d06971d4890f9fb08dbd94b4e9ba170f2d92a2
+  metadata.gz: c4200b3ff85e0fea3d0c4412d81dd7af4cf4a66cdb5d582b871b88a8ac6bc2fc
+  data.tar.gz: d142c51d56ba5b2f1eb445780fc887012e1e199abb767f5edaf85f8badc8ce17
 SHA512:
-  metadata.gz: f11e14acd2e4325710adc68337f10fd3d8ab3736dc5afb9d1dc91d91af5991ac3e9feaf296f337bad37ff5f469d2d4778c9dc33ecfac8314daf95766ebb9684e
-  data.tar.gz: 21c4b3840513e8a19987a9901d5afe1d32f18832869e876c0bc03098165ab703a55a95e101a2092403458c4e1a5314de46d2474ea786c8b69e14a3fb190ceb91
+  metadata.gz: 48701e4dda07a8fa192f320981418ae79c5b744bff3e650935a4fac1485c66878bd19414bc4ca72d7411b5ad829bcbf2b0161ed214818057a459630e76cc267d
+  data.tar.gz: 800b0a224a91684f8f7072adc953665091702bda9aafba80f6898bc009cf466300567a579707f53fba9ab855218e76da543beafacc24c562c6a8f3dd6b77eee5

data/app/controllers/spree/products_controller_decorator.rb

@@ -1,17 +1,16 @@
 module Spree
-    module ProductsControllerDecorator
-      def self.prepended(base)
-        base.before_action :force_razorpay_view_priority
-      end
-  
-      private
-  
-      def force_razorpay_view_priority
-        plugin_theme_path = SpreeRazorpayCheckout::Engine.root.join('app', 'views', 'themes', 'default')
-        prepend_view_path(plugin_theme_path)
+  module ProductsControllerDecorator
+    def self.prepended(base)
+      base.before_action :force_razorpay_view_priority
+    end
+
+    private
 
-      end
+    def force_razorpay_view_priority
+      plugin_theme_path = SpreeRazorpayCheckout::Engine.root.join('app', 'views', 'themes', 'default')
+      prepend_view_path(plugin_theme_path)
     end
   end
-  
-  ::Spree::ProductsController.prepend(Spree::ProductsControllerDecorator)
+end
+
+::Spree::ProductsController.prepend(Spree::ProductsControllerDecorator) if defined?(::Spree::ProductsController)

data/app/controllers/spree/razorpay/webhooks_controller.rb

@@ -0,0 +1,72 @@
+module Spree
+  module Razorpay
+    class WebhooksController < ActionController::API
+      skip_before_action :verify_authenticity_token, raise: false
+
+      # Handles asynchronous background webhooks directly from Razorpay's servers
+      def create
+        payload = request.body.read
+        signature = request.headers['X-Razorpay-Signature']
+        
+        gateway = Spree::Gateway::RazorpayGateway.active.first
+        return head :not_found unless gateway && gateway.preferred_webhook_secret.present?
+
+        begin
+          ::Razorpay::Utility.verify_webhook_signature(
+            payload, 
+            signature, 
+            gateway.preferred_webhook_secret
+          )
+        rescue ::Razorpay::Errors::SignatureVerificationError => e
+          Rails.logger.error("Razorpay Webhook Verification Failed: #{e.message}")
+          return head :unauthorized
+        end
+
+        event = JSON.parse(payload)
+
+        # Listen for 'payment.authorized' which fires immediately after OTP!
+        if ['order.paid', 'payment.captured', 'payment.authorized'].include?(event['event'])
+          ::SpreeRazorpayCheckout::HandleWebhookEventJob.perform_later(event)
+        end
+
+        head :ok
+      end
+
+      # Handles synchronous frontend verification from Next.js Storefront
+      def verify
+        razorpay_order_id = params[:razorpay_order_id]
+        razorpay_payment_id = params[:razorpay_payment_id]
+        razorpay_signature = params[:razorpay_signature]
+
+        session = Spree::PaymentSession.find_by(external_id: razorpay_order_id)
+        return head :not_found unless session
+        
+        # Initialize the Razorpay gem with your active API keys
+        gateway = Spree::Gateway::RazorpayGateway.active.first
+        return render json: { success: false, error: 'Gateway not configured' }, status: :internal_server_error unless gateway
+        gateway.provider 
+
+        begin
+          # 1. Verify the signature securely on the server
+          ::Razorpay::Utility.verify_payment_signature(
+            razorpay_order_id: razorpay_order_id,
+            razorpay_payment_id: razorpay_payment_id,
+            razorpay_signature: razorpay_signature
+          )
+          
+          # 2. Inject the signatures into the session's external_data
+          session.external_data ||= {}
+          session.external_data['razorpay_payment_id'] = razorpay_payment_id
+          session.external_data['razorpay_signature'] = razorpay_signature
+          session.save!
+
+          render json: { success: true }
+        rescue ::Razorpay::Errors::SignatureVerificationError => e
+          Rails.logger.error("Razorpay Frontend Verification Failed: #{e.message}")
+          render json: { success: false, error: e.message }, status: :unprocessable_entity
+        end
+      end
+
+    end
+  end
+end

data/app/javascript/spree_razorpay/application.js

@@ -0,0 +1,12 @@
+import { Application } from '@hotwired/stimulus'
+import CheckoutRazorpayController from './controllers/checkout_razorpay_controller'
+
+let application;
+if (typeof window.Stimulus === "undefined") {
+  application = Application.start()
+  window.Stimulus = application
+} else {
+  application = window.Stimulus
+}
+
+application.register('checkout-razorpay', CheckoutRazorpayController)

data/app/javascript/spree_razorpay/controllers/checkout_razorpay_controller.js

@@ -0,0 +1,108 @@
+import { Controller } from '@hotwired/stimulus'
+
+export default class extends Controller {
+  static values = {
+    paymentMethodId: String,
+    keyId: String,
+    orderId: String,
+    amount: Number,
+    currency: String,
+    merchantName: String,
+    merchantDesc: String,
+    themeColor: String,
+    userName: String,
+    userEmail: String,
+    userContact: String
+  }
+
+  static targets = [
+    'paymentId',
+    'orderId',
+    'signature'
+  ]
+
+  connect() {
+    this.form = document.querySelector("#checkout_form_payment")
+    this.submitBtn = document.getElementById("checkout-payment-submit")
+    
+    // Bind to the form submit event, NOT the button click! 
+    // This perfectly intercepts Spree 5.3's native validation flows.
+    this.submitHandler = this.submit.bind(this)
+    this.form.addEventListener('submit', this.submitHandler)
+  }
+
+  disconnect() {
+    if (this.form) {
+      this.form.removeEventListener('submit', this.submitHandler)
+    }
+  }
+
+  submit(e) {
+    // Check if Razorpay is the currently selected radio button
+    const selectedRadio = document.querySelector('input[name="order[payments_attributes][][payment_method_id]"]:checked');
+    const isRazorpay = selectedRadio && selectedRadio.value === this.paymentMethodIdValue;
+    
+    if (!isRazorpay) return; // If it's a different gateway, let Spree handle it normally
+
+    // If we already have the Razorpay signature populated, let the form submit natively to the backend!
+    if (this.paymentIdTarget.value && this.signatureTarget.value) {
+      return true; 
+    }
+
+    // Otherwise, STOP the form submission and open Razorpay
+    e.preventDefault();
+    e.stopImmediatePropagation();
+    
+    this.setLoading(true);
+
+    const options = {
+      key: this.keyIdValue,
+      order_id: this.orderIdValue,
+      amount: this.amountValue,
+      currency: this.currencyValue,
+      name: this.merchantNameValue,
+      description: this.merchantDescValue,
+      handler: this.handleSuccess.bind(this),
+      modal: {
+        ondismiss: this.handleDismiss.bind(this)
+      },
+      prefill: {
+        name: this.userNameValue,
+        email: this.userEmailValue,
+        contact: this.userContactValue
+      },
+      theme: {
+        color: this.themeColorValue
+      }
+    };
+
+    const rzp = new window.Razorpay(options);
+    rzp.open();
+  }
+
+  handleSuccess(response) {
+    // 1. Populate the hidden fields with the secure response
+    this.paymentIdTarget.value = response.razorpay_payment_id;
+    this.orderIdTarget.value = response.razorpay_order_id;
+    this.signatureTarget.value = response.razorpay_signature;
+
+    // 2. Submit the form natively to Spree's backend!
+    // requestSubmit() ensures Turbo and Spree's event listeners fire correctly
+    this.form.requestSubmit(); 
+  }
+
+  handleDismiss() {
+    this.setLoading(false);
+  }
+
+  setLoading(isLoading) {
+    if (isLoading) {
+      this.submitBtn.disabled = true;
+      this.submitBtn.innerHTML = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> Processing...';
+    } else {
+      this.submitBtn.disabled = false;
+      // Reset Spree button text depending on what it usually says
+      this.submitBtn.innerHTML = 'Save and Continue'; 
+    }
+  }
+}

data/app/jobs/spree_razorpay_checkout/handle_webhook_event_job.rb

@@ -0,0 +1,65 @@
+module SpreeRazorpayCheckout
+    class HandleWebhookEventJob < ActiveJob::Base
+      queue_as :default
+  
+      def perform(event)
+        payload = event['payload']
+        payment_entity = payload.dig('payment', 'entity') || payload.dig('order', 'entity')
+        
+        # Razorpay might send the ID in slightly different places depending on the event
+        razorpay_order_id = payment_entity['order_id'] || payload.dig('order', 'entity', 'id')
+        razorpay_payment_id = payment_entity['id'] 
+        
+        checkout_record = Spree::RazorpayCheckout.find_by(razorpay_order_id: razorpay_order_id)
+        return unless checkout_record
+        
+        order = checkout_record.order
+        return if order.completed? || order.canceled?
+  
+        gateway = Spree::Gateway::RazorpayGateway.active.first
+        return unless gateway
+  
+        order.with_lock do
+          # 1. Capture the abandoned payment via API
+          begin
+            rzp_payment = ::Razorpay::Payment.fetch(razorpay_payment_id)
+            if rzp_payment.status == 'authorized'
+              amount_in_cents = (order.total_minus_store_credits.to_f * 100).to_i
+              rzp_payment.capture({ amount: amount_in_cents })
+            end
+          rescue StandardError => e
+            Rails.logger.error("Webhook Razorpay Capture Failed: #{e.message}")
+            return
+          end
+  
+          checkout_record.update!(
+            razorpay_payment_id: razorpay_payment_id,
+            status: 'captured'
+          )
+  
+          # 2. Create the Spree::Payment record natively
+          payment = order.payments.find_or_create_by!(
+            response_code: razorpay_payment_id,
+            payment_method_id: gateway.id
+          ) do |p|
+            p.amount = order.total
+            p.source = checkout_record
+            p.state = 'checkout'
+          end
+  
+          # 3. Mark the payment as completed
+          payment.process! if payment.checkout?
+          payment.complete! if payment.pending? || payment.processing?
+  
+          # Tell Spree to recalculate the payment state
+          order.updater.update_payment_state
+          
+          # Loop through the checkout steps (Payment -> Confirm -> Complete)
+          until order.completed? || order.state == 'complete'
+            order.next!
+          end
+          
+        end
+      end
+    end
+  end

data/app/models/spree/gateway/razorpay_gateway.rb

@@ -1,24 +1,19 @@
 require 'razorpay'
+require 'active_merchant'
 
 module Spree
   class Gateway::RazorpayGateway < Gateway
-    preference :key_id, :string
-    preference :key_secret, :string
-    preference :test_key_id, :string
-    preference :test_key_secret, :string
+    preference :webhook_secret, :password, default: ''
+    preference :key_id, :string, default: ''
+    preference :key_secret, :password, default: ''
+    preference :test_key_id, :string, default: ''
+    preference :test_key_secret, :password, default: ''
     preference :test_mode, :boolean, default: false
     preference :merchant_name, :string, default: 'Razorpay'
     preference :merchant_description, :text, default: 'Razorpay Payment Gateway'
     preference :merchant_address, :string, default: 'Razorpay, Bangalore, India'
     preference :theme_color, :string, default: '#2e5bff'
-
-    def supports?(_source)
-      true
-    end
-
-    def source_required?
-      false
-    end
+    preference :headless_api_mode, :boolean, default: false
 
     def name
       'Razorpay Secure (UPI, Wallets, Cards & Netbanking)'
@@ -28,10 +23,6 @@ module Spree
       'razorpay'
     end
 
-    def payment_source_class
-      'razorpay'
-    end
-
     def payment_icon_name
       'razorpay'
     end
@@ -49,7 +40,7 @@ module Spree
     end
 
     def provider
-      Razorpay.setup(current_key_id, current_key_secret)
+      ::Razorpay.setup(current_key_id, current_key_secret)
     end
 
     def current_key_id
@@ -69,7 +60,7 @@ module Spree
     end
 
     def actions
-      %w[capture void]
+      %w[capture void credit]
     end
 
     def can_capture?(payment)
@@ -80,63 +71,248 @@ module Spree
       payment.state != 'void'
     end
 
-    # Not used directly (we use custom flow), but kept it for compatibility
-    def purchase(_amount, _transaction_details, _gateway_options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Razorpay success')
+    def supports?(_source)
+      true
+    end
+
+    def session_required?
+      preferred_headless_api_mode
     end
 
-    def capture(*args)
-      simulated_successful_billing_response
+    def source_required?
+      !preferred_headless_api_mode
     end
 
-    def void(*)
-      simulated_successful_billing_response
+    def setup_session_supported?
+      false
+    end
+
+    def payment_source_class
+      Spree::RazorpayCheckout
     end
 
-    def credit(_credit_cents, _payment_id, _options)
-      ActiveMerchant::Billing::Response.new(true, 'Refund successful')
+    def payment_session_class
+      Spree::PaymentSessions::Razorpay if defined?(Spree::PaymentSession)
     end
 
-    def cancel(payment, _options = {})
-     # If `payment` is a Spree::Payment, use its source
-        source = if payment.respond_to?(:source)
-         payment.source else payment end
-         payment.void! if payment.respond_to?(:void!)
-     if source.respond_to?(:razorpay_payment_id)
-      # Uncomment if you want to actually trigger refund
-      # Razorpay::Payment.fetch(source.razorpay_payment_id).refund
-      OpenStruct.new(success?: true, authorization: source.razorpay_payment_id)
-     else
-      # fallback for string/unknown source
-      OpenStruct.new(success?: true, authorization: nil)
-     end
-     rescue => e
-      Rails.logger.error("Razorpay cancel failed: #{e.message}")
-      OpenStruct.new(success?: false, message: e.message)
+    # SPREE 5.4+ HEADLESS API FLOW (Protected by defined? check)
+
+    if defined?(Spree::PaymentSession)
+      def create_payment_session(order:, amount: nil, external_data: {})
+        provider
+        total = amount || order.total_minus_store_credits
+        amount_in_cents = (total.to_f * 100).to_i
+
+        rzp_order = ::Razorpay::Order.create(
+          amount: amount_in_cents,
+          currency: order.currency || 'INR',
+          receipt: order.number,
+          payment_capture: 1,
+          notes: { spree_order_number: order.number, email: order.email }
+        )
+
+        unless rzp_order && rzp_order.attributes.key?('id')
+          raise Spree::Core::GatewayError, 'Failed to create Razorpay session'
+        end
+
+        payment_sessions.create!(
+          type: 'Spree::PaymentSessions::Razorpay',
+          order: order,
+          amount: total,
+          currency: order.currency || 'INR',
+          external_id: rzp_order.id,
+          external_data: { client_key: current_key_id },
+          customer: order.user,
+          status: 'pending'
+        )
+      rescue StandardError => e
+        Rails.logger.error("Razorpay Session Creation Failed: #{e.message}")
+        raise Spree::Core::GatewayError, e.message
+      end
+
+      def update_payment_session(payment_session:, amount: nil, external_data: {})
+        provider
+        
+        if amount.present? && payment_session.amount != amount
+          amount_in_cents = (amount.to_f * 100).to_i
+          
+          new_rzp_order = ::Razorpay::Order.create(
+            amount: amount_in_cents,
+            currency: payment_session.currency,
+            receipt: payment_session.order.number,
+            payment_capture: 1
+          )
+          
+          payment_session.update!(amount: amount, external_id: new_rzp_order.id)
+        end
+        payment_session
+      end
+
+      def complete_payment_session(payment_session:, params: {})
+        provider
+        
+        ext_data = params[:external_data] || params['external_data'] || {}
+        rzp_payment_id = ext_data[:razorpay_payment_id] || ext_data['razorpay_payment_id'] || payment_session.external_data['razorpay_payment_id']
+        rzp_signature  = ext_data[:razorpay_signature] || ext_data['razorpay_signature'] || payment_session.external_data['razorpay_signature']
+
+        begin
+          ::Razorpay::Utility.verify_payment_signature(
+            razorpay_order_id: payment_session.external_id,
+            razorpay_payment_id: rzp_payment_id,
+            razorpay_signature: rzp_signature
+          )
+
+          # Lock the order database row to prevent race conditions with Webhooks
+          payment_session.order.with_lock do
+            
+            # Save the verified IDs into the session so the new Session Class can read them
+            session_data = payment_session.external_data || {}
+            session_data['razorpay_payment_id'] = rzp_payment_id
+            session_data['razorpay_signature'] = rzp_signature
+            payment_session.update!(external_data: session_data)
+
+            # Capture the payment
+            rzp_payment = ::Razorpay::Payment.fetch(rzp_payment_id)
+            if rzp_payment.status == 'authorized'
+              rzp_payment.capture({ amount: (payment_session.amount.to_f * 100).to_i }) 
+            end
+
+            # Process and Create Payment
+            payment_session.process! if payment_session.can_process?
+            
+            # This safely calls your new Spree::PaymentSessions::Razorpay class!
+            payment = payment_session.find_or_create_payment!
+            
+            if payment.present? && !payment.completed?
+              payment.started_processing! if payment.checkout?
+              payment.complete! if payment.can_complete?
+            end
+
+            payment_session.complete! if payment_session.can_complete?
+          end
+
+        rescue StandardError => e
+          Rails.logger.error("Razorpay 5.4 API Completion Failed: #{e.message}")
+          payment_session.fail! if payment_session.can_fail?
+          raise Spree::Core::GatewayError, e.message
+        end
+      end
+
+      def parse_webhook_event(raw_body, headers)
+        provider
+        signature = headers['HTTP_X_RAZORPAY_SIGNATURE'] || headers['X-Razorpay-Signature']
+
+        unless ::Razorpay::Utility.verify_webhook_signature(raw_body, signature, preferred_webhook_secret)
+          raise Spree::PaymentMethod::WebhookSignatureError
+        end
+
+        event = JSON.parse(raw_body)
+        payment_entity = event.dig('payload', 'payment', 'entity') || event.dig('payload', 'order', 'entity')
+        
+        session = Spree::PaymentSession.find_by(external_id: payment_entity['order_id'])
+        return nil unless session
+
+        case event['event']
+        when 'payment.captured', 'payment.authorized'
+          { action: :captured, payment_session: session }
+        when 'payment.failed'
+          { action: :failed, payment_session: session }
+        else
+          nil
+        end
+      rescue ::Razorpay::Errors::SignatureVerificationError
+        raise Spree::PaymentMethod::WebhookSignatureError
+      end
     end
 
-    # Verify signature, fetch payment and capture if required. Returns Razorpay::Payment object.
-    def verify_and_capture_razorpay_payment(order, razorpay_payment_id)
-      Razorpay.setup(current_key_id, current_key_secret)
+    def purchase(_amount, source, _gateway_options = {})
+      provider
 
       begin
-        payment = Razorpay::Payment.fetch(razorpay_payment_id)
-        # If payment is not captured and auto_capture set true, capture it
-        if payment.status == 'authorized'
-          amount = order.inr_amt_in_paise
-          payment = payment.capture(amount: amount)
+        if source.razorpay_payment_id.blank? || source.razorpay_signature.blank?
+           return ActiveMerchant::Billing::Response.new(false, 'Payment was not completed. Please try again.', {}, test: preferred_test_mode)
         end
 
-        payment
-      rescue Razorpay::Error => e
-        raise Spree::Core::GatewayError, "Razorpay error: #{e.message}"
+        ::Razorpay::Utility.verify_payment_signature(
+          razorpay_order_id: source.razorpay_order_id,
+          razorpay_payment_id: source.razorpay_payment_id,
+          razorpay_signature: source.razorpay_signature
+        )
+
+        rzp_payment = ::Razorpay::Payment.fetch(source.razorpay_payment_id)
+        if rzp_payment.status == 'authorized'
+          rzp_payment.capture({ amount: _amount })
+        end
+
+        source.update!(status: 'captured')
+        
+        ActiveMerchant::Billing::Response.new(true, 'Razorpay Payment Successful', {}, test: preferred_test_mode, authorization: source.razorpay_payment_id)
+        
+      rescue StandardError => e
+        Rails.logger.error("Razorpay Verification/Capture Failed: #{e.message}")
+        ActiveMerchant::Billing::Response.new(false, 'Payment verification failed.', {}, test: preferred_test_mode)
+      end
+    end
+
+    def resolve_razorpay_payment_id(response_code)
+      return nil if response_code.blank?
+
+      if response_code.to_s.start_with?('order_')
+        rzp_order = ::Razorpay::Order.fetch(response_code)
+        payments = rzp_order.payments
+        
+        captured_payment = payments.items.find { |p| p.status == 'captured' } || payments.items.first
+        
+        raise StandardError, "No captured payment found for Razorpay Order #{response_code}" unless captured_payment
+        
+        captured_payment.id
+      else
+        response_code
       end
     end
 
-    private
+    def capture(*args)
+      ActiveMerchant::Billing::Response.new(true, 'Already Captured', {}, test: preferred_test_mode)
+    end
+
+    def credit(credit_cents, response_code, _gateway_options = {})
+      provider
+      begin
+        rzp_payment_id = resolve_razorpay_payment_id(response_code)
+        
+        if rzp_payment_id.blank?
+          raise StandardError, "Missing Razorpay Payment ID. Cannot process refund."
+        end
+        
+        refund = ::Razorpay::Refund.create(payment_id: rzp_payment_id, amount: credit_cents.to_i)
+        
+        ActiveMerchant::Billing::Response.new(true, 'Razorpay Refund Successful', { refund_id: refund.id }, test: preferred_test_mode, authorization: refund.id)
+      rescue StandardError => e
+        Rails.logger.error("Razorpay Refund Failed: #{e.message}")
+        ActiveMerchant::Billing::Response.new(false, "Refund failed: #{e.message}", {}, test: preferred_test_mode)
+      end
+    end
+
+    def void(response_code, _gateway_options = {})
+      provider
+      begin
+        rzp_payment_id = resolve_razorpay_payment_id(response_code)
+
+        if rzp_payment_id.blank?
+          raise StandardError, "Missing Razorpay Payment ID. Cannot process void."
+        end
+
+        refund = ::Razorpay::Refund.create(payment_id: rzp_payment_id)
+        
+        ActiveMerchant::Billing::Response.new(true, 'Razorpay Void/Refund Successful', { refund_id: refund.id }, test: preferred_test_mode, authorization: refund.id)
+      rescue StandardError => e
+        Rails.logger.error("Razorpay Void Failed: #{e.message}")
+        ActiveMerchant::Billing::Response.new(false, "Void failed: #{e.message}", {}, test: preferred_test_mode)
+      end
+    end
 
-    def simulated_successful_billing_response
-      ActiveMerchant::Billing::Response.new(true, '', {}, {})
+    def cancel(response_code, _source = nil, _options = {})
+      void(response_code)
     end
   end
-end
+end

data/app/models/spree/page_blocks/products/razorpay_affordability.rb

@@ -55,7 +55,7 @@ module Spree
             is_available = available?(locals)
             Rails.logger.info "  Available check: #{is_available}"
             unless is_available
-              Rails.logger.warn "  ⚠️ Block marked as not available, but rendering anyway"
+              Rails.logger.warn "  Block marked as not available, but rendering anyway"
             end
           end
 
@@ -63,13 +63,13 @@ module Spree
             Rails.logger.info "  Rendering partial: spree/page_blocks/products/razorpay_affordability/razorpay_affordability"
             result = view_context.render partial: 'spree/page_blocks/products/razorpay_affordability/razorpay_affordability',
                                          locals: locals.merge(block: self, page_block: self)
-            Rails.logger.info "  ✅ Render successful, output length: #{result.to_s.length}"
+            Rails.logger.info " Render successful, output length: #{result.to_s.length}"
             result
           rescue ActionView::MissingTemplate => e
-            Rails.logger.error "  ❌ Missing template: #{e.message}"
+            Rails.logger.error "  Missing template: #{e.message}"
             ''
           rescue => e
-            Rails.logger.error "  ❌ Error rendering Razorpay Affordability block: #{e.message}"
+            Rails.logger.error "  Error rendering Razorpay Affordability block: #{e.message}"
             "<div class='razorpay-affordability-error'>Error loading Razorpay Affordability Widget</div>".html_safe
           end
         end