// Shop API authentication
headers: {
  'Authorization': 'Bearer your_api_key',
  'Shop-ID': 'your_shop_id'
}

// Partner API authentication
headers: {
  'Authorization': 'Bearer jwt_token'
}

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 999
X-RateLimit-Reset: 1609459200

{
  "error": {
    "code": "CUSTOMER_NOT_FOUND",
    "message": "Customer with ID 'xyz' not found",
    "details": {
      "customer_id": "xyz",
      "shop_id": "abc123"
    }
  }
}

{
  "customer_id": "cust_123",
  "points": 150,
  "currency": "USD",
  "amount": 99.99,
  "created_at": "2024-01-15T10:30:00Z"
}

# Verify your credentials in Partners Portal
https://partners.loyalty.lt/dashboard

// Make sure you're using the right environment
const isProduction = process.env.NODE_ENV === 'production'
const apiKey = isProduction ? PROD_API_KEY : STAGING_API_KEY

// Correct format
headers: {
  'Authorization': 'Bearer ' + apiKey,  // Note the space after 'Bearer'
  'Shop-ID': shopId,
  'Content-Type': 'application/json'
}

// Ensure customer exists first
const customer = await loyalty.customers.get(customerId)
if (!customer) {
  // Create customer first
  await loyalty.customers.create(customerData)
}

// Points must be positive integers
const points = Math.max(1, Math.floor(calculatedPoints))

// Use unique order IDs to prevent duplicates
await loyalty.points.award({
  customer_id: customerId,
  points: points,
  reason: 'purchase',
  order_id: uniqueOrderId  // This prevents duplicates
})

// Proper webhook verification
const crypto = require('crypto')

function verifyWebhook(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(payload)
    .digest('hex')
  
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(`sha256=${expectedSignature}`)
  )
}

// Webhook handler should return 200
app.post('/webhook', (req, res) => {
  try {
    // Process webhook
    processWebhook(req.body)
    res.status(200).send('OK')  // Important!
  } catch (error) {
    res.status(500).send('Error')
  }
})

// Instead of individual API calls
for (const customer of customers) {
  await loyalty.points.award(customer.id, points)
}

// Use bulk operations
await loyalty.points.bulkAward(customers.map(c => ({
  customer_id: c.id,
  points: points,
  reason: 'bulk_bonus'
})))

// Cache customer data
const cache = new Map()

async function getCustomerPoints(customerId) {
  if (cache.has(customerId)) {
    return cache.get(customerId)
  }
  
  const balance = await loyalty.customers.getBalance(customerId)
  cache.set(customerId, balance, { ttl: 300 }) // 5 minute cache
  return balance
}

// Queue API calls for background processing
const queue = new Queue('loyalty-operations')

queue.add('award-points', {
  customerId,
  points,
  reason
})

// Hook into WooCommerce events
add_action('woocommerce_order_status_completed', 'award_loyalty_points');

function award_loyalty_points($order_id) {
    $order = wc_get_order($order_id);
    $customer_id = $order->get_customer_id();
    $points = calculate_points($order->get_total());
    
    // Award points via API
    $loyalty = new LoyaltyClient($api_key, $shop_id);
    $loyalty->points()->award([
        'customer_id' => $customer_id,
        'points' => $points,
        'reason' => 'purchase',
        'order_id' => $order_id
    ]);
}

// Enable multi-store points in Partner API
await loyalty.partners.updateSettings({
  multi_store_points: true,
  point_sharing: 'full', // 'full', 'earning_only', 'redemption_only'
  unified_tiers: true
})

// When processing a refund
await loyalty.points.deduct({
  customer_id: customerId,
  points: pointsToDeduct,
  reason: 'refund',
  order_id: originalOrderId,
  refund_id: refundId
})

// Calculate proportional point deduction
const originalPoints = 150
const originalAmount = 150.00
const refundAmount = 50.00
const pointsToDeduct = Math.floor((refundAmount / originalAmount) * originalPoints)

// Check if points were already redeemed
const customerBalance = await loyalty.customers.getBalance(customerId)
if (customerBalance.points < pointsToDeduct) {
  // Handle insufficient points scenario
  // Options: partial deduction, negative balance, or block refund
}

import { LoyaltySDK } from '@loyalty-lt/sdk'

// Initialize QR scanner
const scanner = LoyaltySDK.createQRScanner({
  onScan: (qrData) => {
    // Handle scanned loyalty card
    handleLoyaltyCardScan(qrData)
  },
  onError: (error) => {
    console.error('QR scan error:', error)
  }
})

async function handleLoyaltyCardScan(qrData) {
  try {
    const result = await loyalty.loyaltyCards.scan(qrData)
    const customer = result.customer
    
    // Show customer info or award points
    displayCustomerInfo(customer)
  } catch (error) {
    // Handle invalid QR code
    showError('Invalid loyalty card')
  }
}

import { Camera } from 'expo-camera'
import { LoyaltySDK } from '@loyalty-lt/react-native-sdk'

function QRScanner() {
  const handleBarCodeScanned = async ({ data }) => {
    try {
      const result = await LoyaltySDK.scanLoyaltyCard(data)
      // Handle successful scan
    } catch (error) {
      // Handle scan error
    }
  }

  return (
    <Camera
      onBarCodeScanned={handleBarCodeScanned}
      barCodeScannerSettings={{
        barCodeTypes: ['qr'],
      }}
    />
  )
}

LoyaltySDK.init({
  apiKey: 'your_api_key',
  shopId: 'your_shop_id',
  theme: {
    primaryColor: '#007bff',
    secondaryColor: '#6c757d',
    backgroundColor: '#ffffff',
    textColor: '#333333',
    borderRadius: '8px',
    fontFamily: 'Arial, sans-serif'
  }
})

/* Override widget styles */
.loyalty-widget {
  background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
  border-radius: 12px;
  box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
}

.loyalty-points {
  font-size: 24px;
  font-weight: bold;
  color: #ffffff;
}

.loyalty-tier {
  background: rgba(255, 255, 255, 0.2);
  padding: 4px 8px;
  border-radius: 4px;
}

// Custom loyalty card component
function CustomLoyaltyCard({ customer }) {
  return (
    <div className="custom-loyalty-card">
      <div className="card-header">
        <h3>{customer.firstName}'s Rewards</h3>
      </div>
      <div className="card-body">
        <div className="points-display">
          {customer.points} Points
        </div>
        <div className="tier-display">
          {customer.tier} Member
        </div>
      </div>
    </div>
  )
}

// Store customer data locally
import AsyncStorage from '@react-native-async-storage/async-storage'

class OfflineLoyalty {
  async cacheCustomerData(customerId, data) {
    await AsyncStorage.setItem(
      `loyalty_customer_${customerId}`,
      JSON.stringify({
        ...data,
        cached_at: new Date().toISOString()
      })
    )
  }
  
  async getCachedCustomerData(customerId) {
    const cached = await AsyncStorage.getItem(`loyalty_customer_${customerId}`)
    if (cached) {
      const data = JSON.parse(cached)
      // Check if cache is still valid (e.g., less than 1 hour old)
      const isValid = new Date() - new Date(data.cached_at) < 3600000
      return isValid ? data : null
    }
    return null
  }
}

// Queue actions for when connection is restored
class ActionQueue {
  constructor() {
    this.queue = []
  }
  
  addAction(action) {
    this.queue.push({
      ...action,
      timestamp: new Date().toISOString()
    })
    this.saveQueue()
  }
  
  async processQueue() {
    if (!this.isOnline()) return
    
    for (const action of this.queue) {
      try {
        await this.executeAction(action)
        this.removeFromQueue(action)
      } catch (error) {
        // Keep in queue for retry
        console.log('Action failed, will retry:', error)
      }
    }
  }
}

// Implement smart sync when connection restored
NetInfo.addEventListener(state => {
  if (state.isConnected) {
    syncOfflineData()
  }
})

async function syncOfflineData() {
  // Process queued actions
  await actionQueue.processQueue()
  
  // Refresh customer data
  await refreshCustomerData()
  
  // Update local cache
  await updateLocalCache()
}