Conversion Tracking

// On your order confirmation page
const result = await window.badgerfyai.recordConversion({
  orderId: 'ORD-12345',
  orderValue: '299.99'
});

console.log(result);
// { success: true, message: 'Recorded 2 of 2 conversion(s)', recorded: 2, errors: [] }

// Record conversion with full product details
const result = await window.badgerfyai.recordConversion({
  orderId: 'ORD-12345',
  orderValue: '549.98',
  products: [
    {
      productName: 'Wireless Gaming Mouse',
      sku: 'WGM-001',
      price: '79.99',
      quantity: 1,
      category: 'Peripherals'
    },
    {
      productName: 'Mechanical Keyboard',
      sku: 'MK-PRO-002',
      price: '149.99',
      quantity: 1,
      category: 'Peripherals'
    },
    {
      productName: 'USB-C Hub',
      sku: 'HUB-7P',
      price: '39.99',
      quantity: 2,
      category: 'Accessories'
    }
  ]
});

<!-- Order Confirmation Page -->
<script>
  // Wait for BadgerFy.ai to load
  function recordOrderConversion() {
    if (typeof window.badgerfyai === 'undefined') {
      // Script not loaded yet, retry after a short delay
      setTimeout(recordOrderConversion, 500);
      return;
    }

    // Get order data from your page (example using data attributes)
    const orderData = {
      orderId: document.getElementById('order-id').textContent,
      orderValue: document.getElementById('order-total').dataset.value,
      products: JSON.parse(document.getElementById('order-products').dataset.products)
    };

    window.badgerfyai.recordConversion(orderData)
      .then(result => {
        console.log('Conversion recorded:', result);
      })
      .catch(error => {
        console.error('Failed to record conversion:', error);
      });
  }

  // Start the conversion recording process when the page loads
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', recordOrderConversion);
  } else {
    recordOrderConversion();
  }
</script>

// pages/order-confirmation.js
import { useEffect, useState } from 'react';
import { useRouter } from 'next/router';

export default function OrderConfirmation() {
  const router = useRouter();
  const { orderId } = router.query;
  const [order, setOrder] = useState(null);
  const [conversionRecorded, setConversionRecorded] = useState(false);

  // Fetch order details
  useEffect(() => {
    if (orderId) {
      fetchOrderDetails(orderId).then(setOrder);
    }
  }, [orderId]);

  // Record conversion when order is loaded
  useEffect(() => {
    if (!order || conversionRecorded) return;

    const recordConversion = async () => {
      // Wait for BadgerFy.ai to be available
      if (typeof window.badgerfyai === 'undefined') {
        setTimeout(recordConversion, 500);
        return;
      }

      try {
        const result = await window.badgerfyai.recordConversion({
          orderId: order.id,
          orderValue: order.total.toFixed(2),
          products: order.items.map(item => ({
            productName: item.name,
            sku: item.sku,
            price: item.price.toFixed(2),
            quantity: item.quantity,
            category: item.category
          }))
        });

        console.log('Conversion recorded:', result);
        setConversionRecorded(true);
      } catch (error) {
        console.error('Failed to record conversion:', error);
      }
    };

    recordConversion();
  }, [order, conversionRecorded]);

  if (!order) {
    return <div>Loading order details...</div>;
  }

  return (
    <div>
      <h1>Thank you for your order!</h1>
      <p>Order ID: {order.id}</p>
      {/* Rest of your confirmation page */}
    </div>
  );
}

async function fetchOrderDetails(orderId) {
  // Your order fetching logic
  const response = await fetch(`/api/orders/${orderId}`);
  return response.json();
}

{% if first_time_accessed %}
<script>
  // Wait for BadgerFy.ai to load
  function recordShopifyConversion() {
    if (typeof window.badgerfyai === 'undefined') {
      setTimeout(recordShopifyConversion, 500);
      return;
    }

    window.badgerfyai.recordConversion({
      orderId: '{{ order.order_number }}',
      orderValue: '{{ checkout.total_price | money_without_currency | remove: "," }}',
      products: [
        {% for line_item in checkout.line_items %}
        {
          productName: {{ line_item.product.title | json }},
          sku: {{ line_item.sku | json }},
          price: '{{ line_item.final_price | money_without_currency | remove: "," }}',
          quantity: {{ line_item.quantity }},
          category: {{ line_item.product.type | json }}
        }{% unless forloop.last %},{% endunless %}
        {% endfor %}
      ]
    }).then(result => {
      console.log('BadgerFy conversion recorded:', result);
    }).catch(err => {
      console.error('BadgerFy conversion error:', err);
    });
  }

  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', recordShopifyConversion);
  } else {
    recordShopifyConversion();
  }
</script>
{% endif %}

<script>
(function() {
    function recordBigCommerceConversion() {
        if (typeof window.badgerfyai === 'undefined') {
            setTimeout(recordBigCommerceConversion, 500);
            return;
        }
        
        // BigCommerce provides order data in the page context
        // Access via Stencil's injected JSON or data attributes
        var orderData = window.BCData && window.BCData.order;
        
        if (!orderData) {
            // Alternative: try to get from page elements
            var orderIdEl = document.querySelector('[data-order-id]');
            var orderTotalEl = document.querySelector('[data-order-total]');
            
            if (orderIdEl && orderTotalEl) {
                orderData = {
                    id: orderIdEl.dataset.orderId,
                    total: orderTotalEl.dataset.orderTotal
                };
            }
        }
        
        if (!orderData) {
            console.log('BadgerFy: No order data found');
            return;
        }
        
        var products = [];
        if (orderData.items && orderData.items.length) {
            orderData.items.forEach(function(item) {
                products.push({
                    productName: item.name || item.product_name,
                    sku: item.sku || item.product_id,
                    price: (item.price || item.base_price || 0).toString(),
                    quantity: item.quantity || 1,
                    category: item.category || 'Product'
                });
            });
        }
        
        window.badgerfyai.recordConversion({
            orderId: orderData.id || orderData.order_id,
            orderValue: (orderData.total || orderData.grand_total || 0).toString(),
            products: products
        }).then(function(result) {
            console.log('BadgerFy conversion recorded:', result);
        }).catch(function(err) {
            console.error('BadgerFy conversion error:', err);
        });
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', recordBigCommerceConversion);
    } else {
        recordBigCommerceConversion();
    }
})();
</script>

{{! templates/pages/order-confirmation.html }}
{{#if order}}
<script>
(function() {
    function recordConversion() {
        if (typeof window.badgerfyai === 'undefined') {
            setTimeout(recordConversion, 500);
            return;
        }
        
        window.badgerfyai.recordConversion({
            orderId: '{{order.id}}',
            orderValue: '{{order.grand_total.value}}',
            products: [
                {{#each order.items}}
                {
                    productName: {{{json name}}},
                    sku: {{{json sku}}},
                    price: '{{price.value}}',
                    quantity: {{quantity}},
                    category: {{{json category}}}
                }{{#unless @last}},{{/unless}}
                {{/each}}
            ]
        }).then(function(result) {
            console.log('BadgerFy conversion recorded:', result);
        }).catch(function(err) {
            console.error('BadgerFy conversion error:', err);
        });
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', recordConversion);
    } else {
        recordConversion();
    }
})();
</script>
{{/if}}

<?php
/**
 * BadgerFy.ai Conversion Tracking for Magento 2
 * Add this to your success.phtml template
 */

/** @var \Magento\Checkout\Block\Onepage\Success $block */
$order = $block->getOrder();

if ($order): 
    $items = [];
    foreach ($order->getAllVisibleItems() as $item) {
        $items[] = [
            'productName' => $item->getName(),
            'sku' => $item->getSku(),
            'price' => number_format($item->getPrice(), 2, '.', ''),
            'quantity' => (int) $item->getQtyOrdered(),
            'category' => '' // Add category logic if needed
        ];
    }
?>
<script>
(function() {
    function recordMagentoConversion() {
        if (typeof window.badgerfyai === 'undefined') {
            setTimeout(recordMagentoConversion, 500);
            return;
        }
        
        window.badgerfyai.recordConversion({
            orderId: '<?= $block->escapeJs($order->getIncrementId()) ?>',
            orderValue: '<?= $block->escapeJs(number_format($order->getGrandTotal(), 2, '.', '')) ?>',
            products: <?= json_encode($items) ?>
        }).then(function(result) {
            console.log('BadgerFy conversion recorded:', result);
        }).catch(function(err) {
            console.error('BadgerFy conversion error:', err);
        });
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', recordMagentoConversion);
    } else {
        recordMagentoConversion();
    }
})();
</script>
<?php endif; ?>

<!-- app/code/Vendor/BadgerFy/view/frontend/layout/checkout_onepage_success.xml -->
<?xml version="1.0"?>
<page xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="urn:magento:framework:View/Layout/etc/page_configuration.xsd">
    <body>
        <referenceContainer name="content">
            <block class="Vendor\BadgerFy\Block\ConversionTracking"
                   name="badgerfy.conversion.tracking"
                   template="Vendor_BadgerFy::conversion-tracking.phtml"
                   after="-"/>
        </referenceContainer>
    </body>
</page>

<script>
(function() {
    function recordConversion() {
        if (typeof window.badgerfyai === 'undefined') {
            setTimeout(recordConversion, 500);
            return;
        }
        
        // Get order data from dataLayer (requires Enhanced Ecommerce)
        var orderData = null;
        if (window.dataLayer) {
            for (var i = 0; i < window.dataLayer.length; i++) {
                var entry = window.dataLayer[i];
                if (entry.ecommerce && entry.ecommerce.purchase) {
                    orderData = entry.ecommerce.purchase;
                    break;
                }
            }
        }
        
        if (!orderData || !orderData.actionField) {
            console.log('BadgerFy: No purchase data in dataLayer');
            return;
        }
        
        var products = (orderData.products || []).map(function(p) {
            return {
                productName: p.name,
                sku: p.id || p.sku,
                price: (p.price || 0).toString(),
                quantity: p.quantity || 1,
                category: p.category || 'Product'
            };
        });
        
        window.badgerfyai.recordConversion({
            orderId: orderData.actionField.id,
            orderValue: (orderData.actionField.revenue || 0).toString(),
            products: products
        }).then(function(result) {
            console.log('BadgerFy conversion recorded:', result);
        }).catch(function(err) {
            console.error('BadgerFy conversion error:', err);
        });
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', recordConversion);
    } else {
        recordConversion();
    }
})();
</script>

// Add BadgerFy.ai conversion tracking to WooCommerce thank you page
add_action('woocommerce_thankyou', 'badgerfy_record_conversion', 10, 1);

function badgerfy_record_conversion($order_id) {
    if (!$order_id) return;
    
    $order = wc_get_order($order_id);
    if (!$order) return;
    
    // Only run once per order
    if ($order->get_meta('_badgerfy_conversion_tracked')) return;
    
    $items = array();
    foreach ($order->get_items() as $item) {
        $product = $item->get_product();
        $items[] = array(
            'productName' => $item->get_name(),
            'sku' => $product ? $product->get_sku() : '',
            'price' => number_format($item->get_total() / $item->get_quantity(), 2, '.', ''),
            'quantity' => $item->get_quantity(),
            'category' => $product ? implode(', ', wp_get_post_terms($product->get_id(), 'product_cat', array('fields' => 'names'))) : ''
        );
    }
    ?>
    <script>
    (function() {
        function recordConversion() {
            if (typeof window.badgerfyai === 'undefined') {
                setTimeout(recordConversion, 500);
                return;
            }
            
            window.badgerfyai.recordConversion({
                orderId: '<?php echo esc_js($order->get_order_number()); ?>',
                orderValue: '<?php echo esc_js($order->get_total()); ?>',
                products: <?php echo json_encode($items); ?>
            }).then(function(result) {
                console.log('BadgerFy conversion recorded:', result);
            }).catch(function(err) {
                console.error('BadgerFy conversion error:', err);
            });
        }
        
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', recordConversion);
        } else {
            recordConversion();
        }
    })();
    </script>
    <?php
    
    // Mark as tracked to prevent duplicate conversions
    $order->update_meta_data('_badgerfy_conversion_tracked', true);
    $order->save();
}

// Thank You Page Code (Wix Velo)
import wixWindow from 'wix-window';

$w.onReady(function () {
    // Get order data from the page
    // Note: Adjust selectors based on your Thank You page elements
    
    const orderData = wixWindow.getRouterData();
    
    if (orderData && orderData.orderId) {
        recordBadgerFyConversion(orderData);
    }
});

async function recordBadgerFyConversion(orderData) {
    // Wait for BadgerFy.ai to load
    const checkBadgerFy = () => {
        return new Promise((resolve) => {
            const check = () => {
                if (typeof window.badgerfyai !== 'undefined') {
                    resolve();
                } else {
                    setTimeout(check, 500);
                }
            };
            check();
        });
    };
    
    await checkBadgerFy();
    
    try {
        const result = await window.badgerfyai.recordConversion({
            orderId: orderData.orderId,
            orderValue: orderData.totals.total.toString(),
            products: orderData.lineItems.map(item => ({
                productName: item.name,
                sku: item.sku || item.productId,
                price: item.price.toString(),
                quantity: item.quantity,
                category: item.productType || 'Product'
            }))
        });
        
        console.log('BadgerFy conversion recorded:', result);
    } catch (err) {
        console.error('BadgerFy conversion error:', err);
    }
}

<script>
(function() {
    function recordSquarespaceConversion() {
        if (typeof window.badgerfyai === 'undefined') {
            setTimeout(recordSquarespaceConversion, 500);
            return;
        }
        
        // Squarespace provides order data in Y.Squarespace.Commerce object
        var commerce = window.Y && window.Y.Squarespace && window.Y.Squarespace.Commerce;
        if (!commerce || !commerce.currentOrder) {
            console.log('BadgerFy: No order data found');
            return;
        }
        
        var order = commerce.currentOrder;
        var products = [];
        
        if (order.items && order.items.length) {
            order.items.forEach(function(item) {
                products.push({
                    productName: item.productName || item.title,
                    sku: item.sku || item.productId,
                    price: (item.unitPrice / 100).toFixed(2),
                    quantity: item.quantity,
                    category: item.productType || 'Product'
                });
            });
        }
        
        window.badgerfyai.recordConversion({
            orderId: order.orderNumber || order.id,
            orderValue: (order.grandTotal / 100).toFixed(2),
            products: products
        }).then(function(result) {
            console.log('BadgerFy conversion recorded:', result);
        }).catch(function(err) {
            console.error('BadgerFy conversion error:', err);
        });
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', recordSquarespaceConversion);
    } else {
        recordSquarespaceConversion();
    }
})();
</script>

<script>
(function() {
    function recordConversion() {
        if (typeof window.badgerfyai === 'undefined') {
            setTimeout(recordConversion, 500);
            return;
        }
        
        // Read from URL parameters if Squarespace adds them
        var urlParams = new URLSearchParams(window.location.search);
        var orderId = urlParams.get('orderNumber') || 
                      document.querySelector('[data-order-id]')?.dataset.orderId;
        var orderValue = urlParams.get('orderTotal') ||
                         document.querySelector('[data-order-total]')?.dataset.orderTotal;
        
        if (!orderId || !orderValue) {
            console.log('BadgerFy: Could not find order data');
            return;
        }
        
        window.badgerfyai.recordConversion({
            orderId: orderId,
            orderValue: orderValue
        }).then(function(result) {
            console.log('BadgerFy conversion recorded:', result);
        }).catch(function(err) {
            console.error('BadgerFy conversion error:', err);
        });
    }
    
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', recordConversion);
    } else {
        recordConversion();
    }
})();
</script>

// Success response
{
  success: true,
  message: 'Recorded 2 of 2 conversion(s)',
  recorded: 2,    // Number of conversions successfully recorded
  errors: []      // Array of any errors encountered
}

// Partial success (some engagements failed to record)
{
  success: true,
  message: 'Recorded 1 of 2 conversion(s)',
  recorded: 1,
  errors: ['Failed to record conversion for agent 456: Network error']
}

// No engagements to record
{
  success: true,
  message: 'No agent engagements found to convert',
  recorded: 0,
  errors: []
}

// Validation error
{
  success: false,
  message: 'orderId is required',
  recorded: 0,
  errors: ['orderId is required']
}

// Disable default engagement tracking
window.badgerfyaiConfig = {
  engagementConfig: {
    disableDefaultEngagements: true
  }
};

// Then manually record engagements when needed
window.badgerfyai.addAgentEngagement(agentId, 'custom-action');

// Check if a user has engaged with a specific agent
const hasEngaged = window.badgerfyai.hasAgentEngagement(agentId);
// Returns: boolean

// Get engagement details for a specific agent
const engagement = window.badgerfyai.getAgentEngagement(agentId);
// Returns: engagement object or null

// Get all current engagements
const allEngagements = window.badgerfyai.getAllAgentEngagements();
// Returns: array of engagement objects

// Manually add an engagement
window.badgerfyai.addAgentEngagement(agentId, 'custom-action');
// Returns: boolean (true if added, false if already exists)

// Clear engagement for a specific agent
window.badgerfyai.clearAgentEngagement(agentId);
// Returns: boolean

// Clear all engagements
window.badgerfyai.clearAllAgentEngagements();
// Returns: boolean

// Remove expired engagements (called automatically on page load)
window.badgerfyai.cleanupExpiredEngagements();

window.badgerfyaiConfig = {
  onLoad: () => {
    console.log('BadgerFy.ai is ready!');
    
    // Example: Track that BadgerFy is active in your analytics
    analytics.track('BadgerFy Loaded');
    
    // Example: Update UI state
    setIsBadgerFyReady(true);
    
    // Example: Access BadgerFy.ai API
    const agents = window.badgerfyai.getAgents();
    console.log('Active agents:', agents);
  }
};

window.badgerfyaiConfig = {
  onEngagement: ({ agentId, agentType, engagementAction, pagePath }) => {
    console.log('User engaged!', { agentId, agentType, engagementAction, pagePath });
    
    // Example: Send to your analytics platform
    analytics.track('BadgerFy Engagement', {
      agentId,
      agentType,
      action: engagementAction,
      page: pagePath
    });
    
    // Example: Trigger a custom event
    window.dispatchEvent(new CustomEvent('badgerfy:engagement', {
      detail: { agentId, agentType, engagementAction, pagePath }
    }));
  }
};

window.badgerfyaiConfig = {
  // Lifecycle callbacks
  onLoad: () => {
    console.log('BadgerFy.ai initialized');
  },
  
  onEngagement: ({ agentId, agentType, engagementAction, pagePath }) => {
    // Send to Google Analytics 4
    gtag('event', 'badgerfy_engagement', {
      agent_id: agentId,
      agent_type: agentType,
      engagement_action: engagementAction,
      page_path: pagePath
    });
  },
  
  // Optional: Disable default engagement tracking
  // disableDefaultEngagements: true,
  
  // Optional: Tool call handlers
  functions: [
    {
      pageAgentId: 'YOUR_AGENT_ID',
      functionName: 'addToCart',
      functionCall: async (params) => {
        // Your logic here
        return { success: true };
      }
    }
  ]
};