Changeset 3433074

Timestamp:

01/05/2026 09:12:17 PM (7 weeks ago)

Author:

routedev

Message:

version bump

Location:

routeapp/trunk

Files:

• includes/class-routeapp-api-client.php (modified) (4 diffs)
• public/class-routeapp-public.php (modified) (5 diffs)
• public/js/routeapp-public-pbc.js (modified) (4 diffs)
• readme.txt (modified) (2 diffs)
• routeapp.php (modified) (2 diffs)

routeapp/trunk/includes/class-routeapp-api-client.php

@@ -178 +178 @@
     /**
      * Get current quote price based on subtotal
+     * Optimized to store only essential data in session
      * @param $cartRef
      * @param $cartTotal
@@ -203 +204 @@
                 //if creation date is more than 30 minutes, we unset it
                 WC()->session->__unset($key);
+                $lastCalledMade = $key . '-latest';
+                WC()->session->__unset($lastCalledMade);
+                // Clean up all old entries when we find an expired one
+                $this->_cleanup_old_quote_sessions();
             } else {
                 return $cached['result'];
@@ -208 +213 @@
         }
 
-        $cached['createdAt'] = time();
-        $cached['result'] = $this->_make_private_api_call('quotes', array(
+        // Make API call
+        $api_response = $this->_make_private_api_call('quotes', array(
             'merchant_id' => $merchant_id,
             'cart' => [
@@ -220 +225 @@
             ],
         ), 'POST', 'v2');
+
+        // Extract only essential data from API response to minimize session storage
+        $essential_data = $this->_extract_essential_quote_data($api_response);
+
+        // Store only essential data in session (not the full HTTP response)
         if (WC()->session) {
+            // Clean up old entries BEFORE adding new one to enforce limit
+            // This ensures we don't exceed max_entries even when adding a new quote
+            $this->_cleanup_old_quote_sessions();
+            
+            $created_at = time();
+            $cached = array(
+                'createdAt' => $created_at,
+                'result' => $essential_data
+            );
             WC()->session->set($key, $cached);
-            $lastCalledMade = $key. '-latest';
-            WC()->session->set($lastCalledMade, $cached['result']);
-        }
-        return $cached['result'];
+            
+            // Store latest quote data (also minimal)
+            // Format: array with 'body' key for compatibility with routeapp_save_quote_to_order
+            $lastCalledMade = $key . '-latest';
+            WC()->session->set($lastCalledMade, $essential_data);
+            
+            // Track this key for cleanup and limit total entries
+            $this->_track_quote_session_key($key, $created_at);
+            
+            // Clean up again after adding to ensure limit is strictly enforced
+            // This handles the case where we had exactly max_entries before adding
+            $this->_cleanup_old_quote_sessions();
+        }
+
+        return $essential_data;
+    }
+
+    /**
+     * Extract only essential data from API response
+     * Prevents storing full HTTP response objects in session
+     * Stores only: id, premium.amount, premium.currency, payment_responsible.type, payment_responsible.ToggleState
+     * 
+     * @param array|WP_Error $api_response The full API response from wp_remote_request
+     * @return array Minimal quote data in expected format (compatible with existing code)
+     */
+    private function _extract_essential_quote_data($api_response)
+    {
+        // Handle errors - return in expected format
+        if (is_wp_error($api_response)) {
+            return array(
+                'response' => array('code' => 500),
+                'body' => json_encode(array('premium' => array('amount' => '0')))
+            );
+        }
+
+        // Extract body from response
+        $response_code = wp_remote_retrieve_response_code($api_response);
+        $response_body = wp_remote_retrieve_body($api_response);
+
+        // If API call failed, return original format for error handling
+        if ($response_code !== 200 && $response_code !== 201) {
+            return $api_response; // Return original for error handling
+        }
+
+        // Parse JSON body
+        $body_data = json_decode($response_body, true);
+        
+        if (!$body_data || empty($body_data)) {
+            return array(
+                'response' => array('code' => $response_code),
+                'body' => json_encode(array('premium' => array('amount' => '0')))
+            );
+        }
+
+        $essential_quote = array();
+        
+        // Extract essential fields
+        if (isset($body_data['id'])) {
+            $essential_quote['id'] = $body_data['id'];
+        }
+        
+        if (isset($body_data['premium'])) {
+            $essential_quote['premium'] = array(
+                'currency' => isset($body_data['premium']['currency']) ? $body_data['premium']['currency'] : 'USD',
+                'amount' => isset($body_data['premium']['amount']) ? $body_data['premium']['amount'] : '0'
+            );
+        }
+        
+        if (isset($body_data['payment_responsible'])) {
+            $payment = $body_data['payment_responsible'];
+            $essential_quote['payment_responsible'] = array(
+                'type' => isset($payment['type']) ? $payment['type'] : 'paid_by_merchant'
+            );
+           
+            // Convert to boolean ToggleState for compatibility with existing code
+            if (array_key_exists('toggle_state', $payment)) {
+                $toggle_state_value = $payment['toggle_state'];
+                // Convert "checked" -> true, "unchecked" -> false
+                $essential_quote['payment_responsible']['ToggleState'] = ($toggle_state_value === 'checked' || $toggle_state_value === true || $toggle_state_value === 1);
+            } elseif (array_key_exists('ToggleState', $payment)) {
+                // Fallback for camelCase format (if API changes)
+                $essential_quote['payment_responsible']['ToggleState'] = $payment['ToggleState'];
+            }
+        }
+
+        // Return in expected format (compatible with routeapp_get_quote_from_api)
+        return array(
+            'response' => array('code' => $response_code),
+            'body' => json_encode($essential_quote, JSON_FORCE_OBJECT)
+        );
+    }
+
+    /**
+     * Track quote session keys for cleanup management
+     * 
+     * @param string $key Session key
+     * @param int $created_at Timestamp
+     */
+    private function _track_quote_session_key($key, $created_at)
+    {
+        if (!WC()->session) {
+            return;
+        }
+
+        $tracker_key = $this->get_cache_api_session_key() . '_keys';
+        $tracked_keys = WC()->session->get($tracker_key);
+        
+        if (!is_array($tracked_keys)) {
+            $tracked_keys = array();
+        }
+        
+        // Add current key to tracker (avoid duplicates)
+        $key_exists = false;
+        foreach ($tracked_keys as $index => $tracked) {
+            if (isset($tracked['key']) && $tracked['key'] === $key) {
+                $tracked_keys[$index]['time'] = $created_at; // Update timestamp
+                $key_exists = true;
+                break;
+            }
+        }
+        
+        if (!$key_exists) {
+            $tracked_keys[] = array('key' => $key, 'time' => $created_at);
+        }
+        
+        WC()->session->set($tracker_key, $tracked_keys);
+    }
+
+    /**
+     * Clean up old quote session entries to prevent session bloat
+     * Removes entries older than 30 minutes and limits total entries per session
+     * This prevents accumulation of hundreds of quote entries
+     */
+    private function _cleanup_old_quote_sessions()
+    {
+        if (!WC()->session) {
+            return;
+        }
+
+        $cache_prefix = $this->get_cache_api_session_key();
+        $current_time = time();
+        $max_age = 1800; // 30 minutes
+        $max_entries = 5; // Maximum number of quote entries per session (reduced from potential hundreds)
+        
+        // Get tracked keys
+        $tracker_key = $cache_prefix . '_keys';
+        $tracked_keys = WC()->session->get($tracker_key);
+        
+        if (!is_array($tracked_keys) || empty($tracked_keys)) {
+            return;
+        }
+        
+        // Clean up old entries (expired) and verify they still exist in session
+        $valid_keys = array();
+        foreach ($tracked_keys as $key_with_timestamp) {
+            if (!is_array($key_with_timestamp) || !isset($key_with_timestamp['key']) || !isset($key_with_timestamp['time'])) {
+                continue;
+            }
+            
+            $key = $key_with_timestamp['key'];
+            $created_at = $key_with_timestamp['time'];
+            $age = $current_time - $created_at;
+            
+            // Check if entry still exists in session (might have been manually removed)
+            $session_entry = WC()->session->get($key);
+            
+            if ($age > $max_age || !$session_entry) {
+                // Remove expired or missing entry
+                WC()->session->__unset($key);
+                WC()->session->__unset($key . '-latest');
+            } else {
+                // Keep valid entry
+                $valid_keys[] = $key_with_timestamp;
+            }
+        }
+        
+        // Always sort by time (newest first) to prepare for limiting
+        usort($valid_keys, function($a, $b) {
+            return $b['time'] - $a['time'];
+        });
+        
+        // Limit total entries (keep most recent) - STRICTLY enforce max_entries
+        if (count($valid_keys) > $max_entries) {
+            // Keep only max_entries (most recent)
+            $keys_to_keep = array_slice($valid_keys, 0, $max_entries);
+            
+            // Remove excess entries (older ones beyond limit)
+            $keys_to_remove = array_slice($valid_keys, $max_entries);
+            foreach ($keys_to_remove as $excess_entry) {
+                if (isset($excess_entry['key'])) {
+                    $excess_key = $excess_entry['key'];
+                    WC()->session->__unset($excess_key);
+                    WC()->session->__unset($excess_key . '-latest');
+                }
+            }
+            
+            // Update tracker with only kept keys (maintain sorted order)
+            $valid_keys = $keys_to_keep;
+        }
+        
+        // Always update tracker to maintain correct order and remove any orphaned entries
+        WC()->session->set($tracker_key, $valid_keys);
     }
 

routeapp/trunk/public/class-routeapp-public.php

@@ -36 +36 @@
     const ALLOWED_QUOTE_TYPE = 'paid_by_customer';
 
+    const AMPLITUDE_API_KEY = [
+        'production' => '6d4f9158886e0c6d78e3bd97663ba920',
+        'stage' => '99a869d62986f6415610c6741057bc92',
+        'dev' => '527af176070cf4b775c6a718f0737f0a'
+    ];
+
     /**
      * The ID of this plugin.
@@ -44 +50 @@
      */
     private $plugin_name;
+
+    private $route_insurance_data = null;
 
     /**
@@ -390 +398 @@
         $cartItems = $this->get_cart_shippable_items($cart);
         $route_insurance_quote = $this->routeapp_get_quote_from_api($cartRef, $cartTotal, $currency, $cartItems);
+        $this->route_insurance_data = $route_insurance_quote;
 
         $route_insurance_amount = false;
@@ -397 +406 @@
             $route_insurance_amount = $route_insurance_quote->premium->amount;
         }
-        if (is_null($checkbox) && isset($route_insurance_quote->payment_responsible->ToggleState)) {
+       
+        if (is_null($checkbox) && 
+            isset($route_insurance_quote->payment_responsible) && 
+            property_exists($route_insurance_quote->payment_responsible, 'ToggleState')) {
             $checkbox = $route_insurance_quote->payment_responsible->ToggleState;
             WC()->session->set('checkbox_checked', $checkbox);
@@ -482 +494 @@
         wp_enqueue_script($this->plugin_name . '-widget', 'https://protection-widget.route.com/route-protection-widget.js', array(), $this->version, false);
 
-        wp_enqueue_script($this->plugin_name, plugin_dir_url(__FILE__) . 'js/routeapp-public-pbc.js', array('jquery'), $this->version, false);
+        $amplitude_key = self::AMPLITUDE_API_KEY[$custom_env];
+
+        // Load Amplitude SDK (standard version, not snippet)
+        wp_enqueue_script('amplitude-js', "https://cdn.amplitude.com/script/$amplitude_key.js", array(), null, false);
+
+        // Enqueue Amplitude Analytics module (depends on jQuery and Amplitude SDK)
+        wp_enqueue_script($this->plugin_name . '-amplitude-analytics', plugin_dir_url(__FILE__) . 'js/amplitude-analytics.js', array('jquery', 'amplitude-js'), $this->version, false);
+
+        // Main script depends on amplitude-analytics when available
+        wp_enqueue_script($this->plugin_name, plugin_dir_url(__FILE__) . 'js/routeapp-public-pbc.js', array('jquery', $this->plugin_name . '-amplitude-analytics'), $this->version, false);
+
+        /**
+         * Calculate total Route fee
+         * Uses the premium amount from route insurance data if available,
+         * otherwise defaults to 0.98 as a fallback fee amount
+         */
+        $totalRouteFee = (is_object($this->route_insurance_data) && isset($this->route_insurance_data->premium->amount))
+            ? (float) $this->route_insurance_data->premium->amount
+            : 0.98;
+
+        // Pass cart data to JavaScript - send to amplitude-analytics.js
+        wp_localize_script($this->plugin_name . '-amplitude-analytics', 'cartData', array(
+            'cartId' => WC()->cart->get_cart_hash(),
+            'amplitudeKey' => $amplitude_key,
+            'widgetId' => uniqid('widget-', true),
+            'subtotal' => round($this->get_cart_subtotal_with_only_shippable_items(WC()->cart), 2),
+            'totalRouteFee' => $totalRouteFee,
+            'environment' => $custom_env,
+            'currency' => get_woocommerce_currency(),
+            'merchantId' => $this->routeapp_api_client->get_merchant_id(),
+        ));
 
         wp_enqueue_style($this->plugin_name . '-widget', plugin_dir_url(__FILE__) . 'css/routeapp-widget.css', array(), $this->version, false);

routeapp/trunk/public/js/routeapp-public-pbc.js

@@ -23 +23 @@
             is_cart_page: window.location.pathname === "/cart/",
             invalid_shipping_method: '.routeapp-invalid-shipping-method',
-            checkbox: $(PROTECTION_COOKIE).length ? parseCheckboxValue() : Route.Coverage.ActiveByDefault,
+            checkbox: $(PROTECTION_COOKIE).length ? parseCheckboxValue() : Route.Coverage.ActiveByDefault
         };
 
@@ -63 +63 @@
                 success: function () {
                     RouteConfig.is_cart_page ? triggerCartUpdate() : triggerCheckoutUpdate();
+
+                    // Track protection change using RouteAmplitudeAnalytics
+                    if (window.RouteAmplitudeAnalytics) {
+                        RouteAmplitudeAnalytics.trackProtectChange(checkbox);
+                    }
                 }
             });
@@ -108 +113 @@
                         $(ROUTE_WIDGET_ID).show();
                         renderWidget(result['routeapp-subtotal']);
+                        // Track widget render using RouteAmplitudeAnalytics
+                        if (window.RouteAmplitudeAnalytics) {
+                            RouteAmplitudeAnalytics.trackWidgetRender();
+                        }
                     } else {
                         $(ROUTE_WIDGET_ID).hide();
@@ -119 +128 @@
         $(document.body).on( UPDATED_CHECKOUT_EVENT, checkWidgetShow);
 
+        // Initialize Amplitude analytics using RouteAmplitudeAnalytics
+        if (window.RouteAmplitudeAnalytics) {
+            RouteAmplitudeAnalytics.initialize();
+        }
+
+        // Set up event listeners for info modal tracking
+        // Listen for clicks on Route widget info buttons
+        $(document).on('click', '#RouteWidget .pw-info-icon', function() {
+            if (window.RouteAmplitudeAnalytics) {
+                RouteAmplitudeAnalytics.trackInfoChange('opened');
+            }
+        });
+        
+        // Listen for modal close events
+        $(document).on('click', '#RouteWidget .route-modal__close', function() {
+            if (window.RouteAmplitudeAnalytics) {
+                RouteAmplitudeAnalytics.trackInfoChange('closed');
+            }
+        });
+
         if (!$(RouteConfig.invalid_shipping_method).length) {
             renderWidget($(RouteConfig.subtotal).val());

routeapp/trunk/readme.txt

@@ -6 +6 @@
 Requires at least: 4.0
 Tested up to: 6.7.1
-Stable tag: 2.2.29
+Stable tag: 2.2.32
 Requires PHP: 5.6
 License: GPLv2 or later
@@ -106 +106 @@
 
 == Changelog ==
+
+= 2.2.32 =
+* Update plugin version
+
+= 2.2.31 =
+* Fix session bloat issue by optimizing quote data storage
+
+= 2.2.30 =
+* Add Amplitude tracking for Route widget interactions
 
 = 2.2.29 =

routeapp/trunk/routeapp.php

@@ -10 +10 @@
  * Plugin URI:        https://route.com/for-merchants/
  * Description:       Route allows shoppers to insure their orders with one-click during checkout, adding a layer of 3rd party trust while improving the customer shopping experience.
- * Version:           2.2.29
+ * Version:           2.2.32
  * Author:            Route
  * Author URI:        https://route.com/
@@ -26 +26 @@
  * Currently plugin version.
  */
-define( 'ROUTEAPP_VERSION', '2.2.29' );
+define( 'ROUTEAPP_VERSION', '2.2.32' );
 
 /**