Shopify Plus企业级解决方案指南

# Flow模板：低库存自动补货
trigger:
  type: "inventory_level_low"
  threshold: 10
 
conditions:
  - product_vendor: "Main Supplier"
  - product_availability: "available"
 
actions:
  - create_purchase_order:
      supplier: "{{ product.vendor }}"
      quantity: "{{ product.optimal_stock_level }}"
      notes: "Auto-generated reorder for {{ product.title }}"
  
  - send_email:
      to: "[email protected]"
      subject: "Low inventory alert: {{ product.title }}"
      body: "Product {{ product.title }} has fallen below threshold. Purchase order created."

# Flow模板：VIP客户自动标记
trigger:
  type: "order_paid"
 
conditions:
  - customer_total_spent: ">= 10000"
  - customer_orders_count: ">= 5"
 
actions:
  - add_customer_tag: "VIP"
  - add_customer_tag: "High Value"
  
  - send_email:
      to: "{{ customer.email }}"
      template: "vip_welcome"
      
  - create_discount:
      type: "percentage"
      value: 15
      customer_id: "{{ customer.id }}"
      expires_at: "30 days from now"

# Flow模板：大额订单特殊处理
trigger:
  type: "order_created"
 
conditions:
  - order_total: ">= 5000"
  - shipping_country: ["US", "CA", "GB"]
 
actions:
  - add_order_tag: "high_value"
  - assign_location: "premium_warehouse"
  
  - send_internal_notification:
      to: "[email protected]"
      message: "High value order {{ order.name }} requires priority processing"
      
  - update_order_priority: "high"
  
  - add_timeline_comment:
      message: "Order flagged for priority processing due to high value"

# 批量折扣定价脚本
class VolumeDiscountScript
  def initialize
    @volume_tiers = [
      { min_quantity: 10, discount: 0.05 },
      { min_quantity: 25, discount: 0.10 },
      { min_quantity: 50, discount: 0.15 },
      { min_quantity: 100, discount: 0.20 }
    ]
  end
 
  def run(cart)
    cart.line_items.each do |line_item|
      apply_volume_discount(line_item)
    end
  end
 
  private
 
  def apply_volume_discount(line_item)
    quantity = line_item.quantity
    
    applicable_tier = @volume_tiers
      .select { |tier| quantity >= tier[:min_quantity] }
      .max_by { |tier| tier[:min_quantity] }
    
    if applicable_tier
      discount_amount = line_item.line_price * applicable_tier[:discount]
      
      line_item.change_line_price(
        line_item.line_price - discount_amount,
        message: "Volume discount (#{(applicable_tier[:discount] * 100).to_i}%)"
      )
    end
  end
end
 
VolumeDiscountScript.new.run(Input.cart)
Output.cart = Input.cart

# 基于重量和距离的动态运费计算
class SmartShippingScript
  def initialize
    @weight_rates = {
      0..1 => 5.00,
      1..5 => 8.00,
      5..10 => 12.00,
      10..Float::INFINITY => 20.00
    }
    
    @zone_multipliers = {
      'US' => 1.0,
      'CA' => 1.2,
      'EU' => 1.5,
      'INTL' => 2.0
    }
  end
 
  def run(rates)
    rates.each do |rate|
      adjust_shipping_rate(rate)
    end
  end
 
  private
 
  def adjust_shipping_rate(rate)
    total_weight = calculate_total_weight
    shipping_zone = determine_shipping_zone(rate.destination)
    
    base_rate = calculate_base_rate(total_weight)
    zone_multiplier = @zone_multipliers[shipping_zone] || 2.0
    
    final_rate = base_rate * zone_multiplier
    
    # 免费配送门槛
    if Input.cart.subtotal_price >= Money.new(cents: 10000) # $100
      final_rate = Money.new(cents: 0)
    end
    
    rate.apply_discount(
      rate.price - final_rate,
      message: "Smart shipping calculation"
    )
  end
 
  def calculate_total_weight
    Input.cart.line_items.sum(&:variant.weight)
  end
 
  def determine_shipping_zone(destination)
    case destination.country_code
    when 'US' then 'US'
    when 'CA' then 'CA'
    when /^(GB|DE|FR|IT|ES|NL)$/ then 'EU'
    else 'INTL'
    end
  end
 
  def calculate_base_rate(weight)
    tier = @weight_rates.find { |range, _| range.cover?(weight) }
    Money.new(cents: (tier.last * 100).to_i)
  end
end
 
SmartShippingScript.new.run(Input.shipping_rates)
Output.shipping_rates = Input.shipping_rates

# 基于条件的支付方式过滤
class PaymentMethodScript
  def initialize
    @restricted_methods = {
      'buy_now_pay_later' => {
        min_amount: Money.new(cents: 5000), # $50最低金额
        excluded_countries: ['US', 'CA']
      },
      'cryptocurrency' => {
        min_amount: Money.new(cents: 10000), # $100最低金额
        vip_only: true
      }
    }
  end
 
  def run(payment_methods)
    payment_methods.each do |method|
      apply_restrictions(method)
    end
  end
 
  private
 
  def apply_restrictions(method)
    restrictions = @restricted_methods[method.name]
    return unless restrictions
 
    # 检查最低金额
    if restrictions[:min_amount] && Input.cart.subtotal_price < restrictions[:min_amount]
      method.reject(message: "Minimum order amount not met")
      return
    end
 
    # 检查地区限制
    if restrictions[:excluded_countries]&.include?(Input.cart.shipping_address.country_code)
      method.reject(message: "Not available in your region")
      return
    end
 
    # 检查VIP限制
    if restrictions[:vip_only] && !customer_is_vip?
      method.reject(message: "VIP customers only")
      return
    end
  end
 
  def customer_is_vip?
    Input.cart.customer&.tags&.include?('VIP')
  end
end
 
PaymentMethodScript.new.run(Input.payment_methods)
Output.payment_methods = Input.payment_methods

{
  "launchpad": {
    "name": "Black Friday Flash Sale",
    "description": "24-hour flash sale with automatic price changes",
    "start_time": "2024-11-29T00:00:00Z",
    "end_time": "2024-11-29T23:59:59Z",
    "timezone": "America/New_York",
    
    "changes": [
      {
        "type": "product_price_change",
        "target": {
          "collection_id": "flash-sale-collection"
        },
        "action": {
          "discount_type": "percentage",
          "discount_value": 50,
          "compare_at_price": true
        }
      },
      {
        "type": "theme_setting_change",
        "target": {
          "setting_name": "announcement_bar_text"
        },
        "action": {
          "value": "⚡ Flash Sale: 50% Off Everything! Limited Time Only!"
        }
      },
      {
        "type": "inventory_management",
        "target": {
          "collection_id": "flash-sale-collection"
        },
        "action": {
          "track_inventory": true,
          "low_stock_threshold": 5
        }
      }
    ],
    
    "post_event_actions": [
      {
        "type": "restore_original_prices",
        "delay_minutes": 0
      },
      {
        "type": "send_summary_report",
        "recipients": ["[email protected]"]
      }
    ]
  }
}

{
  "launchpad": {
    "name": "New Product Line Launch",
    "description": "Coordinated launch of summer collection",
    "start_time": "2024-06-01T09:00:00Z",
    "end_time": "2024-06-01T18:00:00Z",
    
    "pre_launch_setup": {
      "days_before": 7,
      "actions": [
        {
          "type": "create_collection",
          "name": "Summer 2024 Collection",
          "products": "tagged:summer-2024"
        },
        {
          "type": "setup_email_campaign",
          "template": "product_launch_teaser",
          "segment": "vip_customers"
        }
      ]
    },
    
    "launch_actions": [
      {
        "type": "publish_products",
        "target": {
          "tag": "summer-2024-preview"
        },
        "timing": "00:00"
      },
      {
        "type": "update_homepage",
        "hero_section": {
          "image": "summer-collection-hero.jpg",
          "title": "Discover Summer 2024",
          "cta_text": "Shop Now"
        },
        "timing": "00:05"
      },
      {
        "type": "send_launch_email",
        "template": "product_launch_announcement",
        "segment": "all_subscribers",
        "timing": "09:00"
      },
      {
        "type": "social_media_post",
        "platforms": ["instagram", "facebook", "twitter"],
        "content": "🌞 Summer 2024 Collection is here! Shop the latest trends.",
        "timing": "09:30"
      }
    ]
  }
}

// 多店铺数据同步服务
class MultiStoreSync {
  constructor(masterStore, childStores) {
    this.masterStore = masterStore
    this.childStores = childStores
    this.syncQueue = []
  }
 
  async syncProductData(productId) {
    // 从主店铺获取产品数据
    const masterProduct = await this.fetchProduct(this.masterStore, productId)
    
    // 同步到所有子店铺
    const syncPromises = this.childStores.map(store => 
      this.syncProductToStore(store, masterProduct)
    )
    
    const results = await Promise.allSettled(syncPromises)
    
    return {
      success: results.filter(r => r.status === 'fulfilled').length,
      failed: results.filter(r => r.status === 'rejected').length,
      details: results
    }
  }
 
  async syncProductToStore(store, productData) {
    try {
      // 检查产品是否已存在
      const existingProduct = await this.findProductByHandle(store, productData.handle)
      
      if (existingProduct) {
        // 更新现有产品
        return await this.updateProduct(store, existingProduct.id, {
          title: productData.title,
          body_html: productData.body_html,
          product_type: productData.product_type,
          vendor: productData.vendor,
          tags: productData.tags,
          images: productData.images,
          variants: this.adaptVariants(productData.variants, store.currency)
        })
      } else {
        // 创建新产品
        return await this.createProduct(store, {
          ...productData,
          variants: this.adaptVariants(productData.variants, store.currency)
        })
      }
    } catch (error) {
      console.error(`Failed to sync product to ${store.domain}:`, error)
      throw error
    }
  }
 
  adaptVariants(variants, currency) {
    return variants.map(variant => ({
      ...variant,
      price: this.convertPrice(variant.price, currency),
      compare_at_price: variant.compare_at_price ? 
        this.convertPrice(variant.compare_at_price, currency) : null
    }))
  }
 
  convertPrice(price, targetCurrency) {
    // 实现汇率转换逻辑
    const exchangeRates = {
      'USD': 1.0,
      'EUR': 0.85,
      'GBP': 0.73,
      'CAD': 1.25,
      'AUD': 1.35
    }
    
    return (parseFloat(price) * exchangeRates[targetCurrency]).toFixed(2)
  }
 
  async batchSyncInventory() {
    const inventoryUpdates = []
    
    for (const store of this.childStores) {
      const products = await this.fetchAllProducts(store)
      
      for (const product of products) {
        for (const variant of product.variants) {
          inventoryUpdates.push({
            store: store.domain,
            variant_id: variant.id,
            quantity: await this.getInventoryQuantity(this.masterStore, variant.sku)
          })
        }
      }
    }
    
    // 批量更新库存
    return await this.executeBatchInventoryUpdate(inventoryUpdates)
  }
}

// Plus级别的高级分析报表
class PlusAnalytics {
  constructor(stores) {
    this.stores = stores
    this.reportCache = new Map()
  }
 
  async generateUnifiedReport(startDate, endDate) {
    const reports = await Promise.all(
      this.stores.map(store => this.generateStoreReport(store, startDate, endDate))
    )
    
    return this.aggregateReports(reports)
  }
 
  async generateStoreReport(store, startDate, endDate) {
    const [orders, products, customers] = await Promise.all([
      this.fetchOrdersAnalytics(store, startDate, endDate),
      this.fetchProductsAnalytics(store, startDate, endDate),
      this.fetchCustomersAnalytics(store, startDate, endDate)
    ])
    
    return {
      store: store.domain,
      period: { startDate, endDate },
      metrics: {
        revenue: {
          total: orders.total_sales,
          avg_order_value: orders.total_sales / orders.orders_count,
          orders_count: orders.orders_count
        },
        products: {
          total_sold: products.total_sold,
          top_performers: products.top_performers,
          inventory_turns: products.inventory_turns
        },
        customers: {
          new_customers: customers.new_customers,
          returning_customers: customers.returning_customers,
          customer_lifetime_value: customers.lifetime_value
        },
        conversion: {
          conversion_rate: this.calculateConversionRate(store, startDate, endDate),
          cart_abandonment_rate: this.calculateAbandonmentRate(store, startDate, endDate)
        }
      }
    }
  }
 
  async fetchOrdersAnalytics(store, startDate, endDate) {
    const query = `
      query ordersAnalytics($query: String!) {
        orders(first: 250, query: $query) {
          edges {
            node {
              id
              name
              totalPriceSet {
                shopMoney {
                  amount
                }
              }
              processedAt
              customer {
                id
                ordersCount
              }
              lineItems(first: 250) {
                edges {
                  node {
                    quantity
                    variant {
                      product {
                        handle
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    `
    
    const response = await this.executeGraphQLQuery(store, query, {
      query: `processed_at:>='${startDate}' AND processed_at:<='${endDate}'`
    })
    
    return this.processOrdersData(response.data.orders)
  }
 
  processOrdersData(ordersData) {
    const orders = ordersData.edges.map(edge => edge.node)
    
    return {
      orders_count: orders.length,
      total_sales: orders.reduce((sum, order) => 
        sum + parseFloat(order.totalPriceSet.shopMoney.amount), 0
      ),
      new_customer_orders: orders.filter(order => 
        order.customer && order.customer.ordersCount === 1
      ).length,
      repeat_customer_orders: orders.filter(order => 
        order.customer && order.customer.ordersCount > 1
      ).length
    }
  }
 
  aggregateReports(reports) {
    const aggregated = {
      summary: {
        total_revenue: 0,
        total_orders: 0,
        average_order_value: 0,
        total_customers: 0
      },
      by_store: reports,
      trends: this.calculateTrends(reports),
      insights: this.generateInsights(reports)
    }
    
    // 计算汇总数据
    reports.forEach(report => {
      aggregated.summary.total_revenue += report.metrics.revenue.total
      aggregated.summary.total_orders += report.metrics.revenue.orders_count
      aggregated.summary.total_customers += report.metrics.customers.new_customers
    })
    
    aggregated.summary.average_order_value = 
      aggregated.summary.total_revenue / aggregated.summary.total_orders
    
    return aggregated
  }
 
  generateInsights(reports) {
    const insights = []
    
    // 找出表现最好的店铺
    const topStore = reports.reduce((max, current) => 
      current.metrics.revenue.total > max.metrics.revenue.total ? current : max
    )
    
    insights.push({
      type: 'top_performer',
      message: `${topStore.store} is the top performing store with $${topStore.metrics.revenue.total.toFixed(2)} in revenue`,
      value: topStore.metrics.revenue.total
    })
    
    // 识别库存周转率低的产品
    const lowTurnoverStores = reports.filter(report => 
      report.metrics.products.inventory_turns < 2
    )
    
    if (lowTurnoverStores.length > 0) {
      insights.push({
        type: 'inventory_warning',
        message: `${lowTurnoverStores.length} stores have low inventory turnover rates`,
        stores: lowTurnoverStores.map(s => s.store)
      })
    }
    
    return insights
  }
}

// B2B批发价格系统
class WholesalePricing {
  constructor() {
    this.customerTiers = {
      'wholesale_basic': { discount: 0.15, min_order: 500 },
      'wholesale_premium': { discount: 0.25, min_order: 1000 },
      'wholesale_enterprise': { discount: 0.35, min_order: 2500 }
    }
  }
 
  async applyWholesalePricing(customerId, cart) {
    const customer = await this.getCustomer(customerId)
    const customerTier = this.getCustomerTier(customer)
    
    if (!customerTier) {
      return cart // 非批发客户，保持原价
    }
    
    const tierConfig = this.customerTiers[customerTier]
    
    // 检查最低订单金额
    if (cart.subtotal < tierConfig.min_order) {
      throw new Error(`Minimum order amount of $${tierConfig.min_order} required for wholesale pricing`)
    }
    
    // 应用批发折扣
    const updatedCart = {
      ...cart,
      line_items: cart.line_items.map(item => ({
        ...item,
        price: this.calculateWholesalePrice(item.price, tierConfig.discount),
        line_price: this.calculateWholesalePrice(item.line_price, tierConfig.discount)
      }))
    }
    
    updatedCart.subtotal = updatedCart.line_items.reduce(
      (sum, item) => sum + item.line_price, 0
    )
    
    return updatedCart
  }
 
  calculateWholesalePrice(originalPrice, discount) {
    return parseFloat((originalPrice * (1 - discount)).toFixed(2))
  }
 
  getCustomerTier(customer) {
    const tags = customer.tags || []
    
    if (tags.includes('wholesale_enterprise')) return 'wholesale_enterprise'
    if (tags.includes('wholesale_premium')) return 'wholesale_premium'
    if (tags.includes('wholesale_basic')) return 'wholesale_basic'
    
    return null
  }
 
  async createWholesaleQuote(customerId, items, validUntil) {
    const customer = await this.getCustomer(customerId)
    const tierConfig = this.customerTiers[this.getCustomerTier(customer)]
    
    const quote = {
      id: this.generateQuoteId(),
      customer_id: customerId,
      created_at: new Date().toISOString(),
      valid_until: validUntil,
      status: 'pending',
      items: items.map(item => ({
        ...item,
        wholesale_price: this.calculateWholesalePrice(item.price, tierConfig.discount),
        savings: item.price - this.calculateWholesalePrice(item.price, tierConfig.discount)
      })),
      total_savings: items.reduce((sum, item) => 
        sum + (item.price - this.calculateWholesalePrice(item.price, tierConfig.discount)) * item.quantity, 0
      )
    }
    
    // 保存报价到数据库
    await this.saveQuote(quote)
    
    // 发送报价邮件
    await this.sendQuoteEmail(customer, quote)
    
    return quote
  }
}

// 企业客户管理系统
class CompanyAccountManager {
  async createCompanyAccount(companyData, adminUserData) {
    // 创建公司账户
    const company = await this.createCompany({
      name: companyData.name,
      tax_id: companyData.tax_id,
      billing_address: companyData.billing_address,
      shipping_addresses: companyData.shipping_addresses,
      payment_terms: companyData.payment_terms || 'net_30',
      credit_limit: companyData.credit_limit || 0,
      status: 'active'
    })
    
    // 创建管理员用户
    const adminUser = await this.createCompanyUser({
      ...adminUserData,
      company_id: company.id,
      role: 'admin',
      permissions: ['place_orders', 'manage_users', 'view_reports']
    })
    
    // 设置默认购买规则
    await this.setupPurchaseRules(company.id, {
      approval_required: companyData.requires_approval || false,
      spending_limit_per_user: companyData.user_spending_limit || null,
      allowed_payment_methods: companyData.allowed_payment_methods || ['net_terms'],
      restricted_products: companyData.restricted_products || []
    })
    
    return { company, admin_user: adminUser }
  }
 
  async addCompanyUser(companyId, userData, permissions = []) {
    const company = await this.getCompany(companyId)
    
    if (!company) {
      throw new Error('Company not found')
    }
    
    const user = await this.createCompanyUser({
      ...userData,
      company_id: companyId,
      role: userData.role || 'member',
      permissions: permissions.length > 0 ? permissions : ['place_orders']
    })
    
    // 发送欢迎邮件
    await this.sendWelcomeEmail(user, company)
    
    return user
  }
 
  async processCompanyOrder(orderId, userId) {
    const order = await this.getOrder(orderId)
    const user = await this.getCompanyUser(userId)
    const company = await this.getCompany(user.company_id)
    const rules = await this.getPurchaseRules(company.id)
    
    // 检查权限
    if (!user.permissions.includes('place_orders')) {
      throw new Error('User does not have permission to place orders')
    }
    
    // 检查支出限制
    if (rules.spending_limit_per_user && order.total > rules.spending_limit_per_user) {
      throw new Error('Order exceeds user spending limit')
    }
    
    // 检查公司信用限制
    const outstandingBalance = await this.getCompanyOutstandingBalance(company.id)
    if (company.credit_limit && (outstandingBalance + order.total) > company.credit_limit) {
      throw new Error('Order would exceed company credit limit')
    }
    
    // 检查是否需要审批
    if (rules.approval_required && order.total > rules.approval_threshold) {
      return await this.submitForApproval(order, user, company)
    }
    
    // 直接处理订单
    return await this.processOrder(order, company)
  }
 
  async submitForApproval(order, user, company) {
    const approval = await this.createApprovalRequest({
      order_id: order.id,
      requested_by: user.id,
      company_id: company.id,
      amount: order.total,
      status: 'pending',
      requested_at: new Date().toISOString()
    })
    
    // 通知管理员
    const admins = await this.getCompanyAdmins(company.id)
    await Promise.all(
      admins.map(admin => this.sendApprovalNotification(admin, approval, order))
    )
    
    return { status: 'pending_approval', approval_id: approval.id }
  }
}

// ERP系统双向同步
class ERPIntegration {
  constructor(erpConfig) {
    this.erpEndpoint = erpConfig.endpoint
    this.apiKey = erpConfig.apiKey
    this.syncInterval = erpConfig.syncInterval || 300000 // 5分钟
    this.lastSyncTimestamp = null
  }
 
  async startSync() {
    console.log('Starting ERP sync...')
    
    setInterval(async () => {
      try {
        await this.performBidirectionalSync()
      } catch (error) {
        console.error('ERP sync failed:', error)
        await this.notifyAdministrators(error)
      }
    }, this.syncInterval)
  }
 
  async performBidirectionalSync() {
    const lastSync = this.lastSyncTimestamp || new Date(Date.now() - this.syncInterval)
    
    // 从Shopify同步到ERP
    await this.syncShopifyToERP(lastSync)
    
    // 从ERP同步到Shopify
    await this.syncERPToShopify(lastSync)
    
    this.lastSyncTimestamp = new Date()
  }
 
  async syncShopifyToERP(since) {
    // 同步新订单
    const newOrders = await this.fetchShopifyOrders(since)
    
    for (const order of newOrders) {
      await this.sendOrderToERP(order)
    }
    
    // 同步客户数据
    const newCustomers = await this.fetchShopifyCustomers(since)
    
    for (const customer of newCustomers) {
      await this.sendCustomerToERP(customer)
    }
    
    // 同步产品数据
    const updatedProducts = await this.fetchUpdatedProducts(since)
    
    for (const product of updatedProducts) {
      await this.sendProductToERP(product)
    }
  }
 
  async syncERPToShopify(since) {
    // 同步库存更新
    const inventoryUpdates = await this.fetchERPInventoryUpdates(since)
    
    for (const update of inventoryUpdates) {
      await this.updateShopifyInventory(update)
    }
    
    // 同步价格更新
    const priceUpdates = await this.fetchERPPriceUpdates(since)
    
    for (const update of priceUpdates) {
      await this.updateShopifyPrice(update)
    }
    
    // 同步履约状态
    const fulfillmentUpdates = await this.fetchERPFulfillmentUpdates(since)
    
    for (const update of fulfillmentUpdates) {
      await this.updateShopifyFulfillment(update)
    }
  }
 
  async sendOrderToERP(shopifyOrder) {
    const erpOrder = this.transformShopifyOrderToERP(shopifyOrder)
    
    const response = await fetch(`${this.erpEndpoint}/orders`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(erpOrder)
    })
    
    if (!response.ok) {
      throw new Error(`Failed to send order ${shopifyOrder.name} to ERP: ${response.statusText}`)
    }
    
    const erpResponse = await response.json()
    
    // 在Shopify订单中记录ERP订单ID
    await this.updateShopifyOrderMetafield(shopifyOrder.id, 'erp_order_id', erpResponse.id)
  }
 
  transformShopifyOrderToERP(shopifyOrder) {
    return {
      external_id: shopifyOrder.id,
      order_number: shopifyOrder.name,
      customer: {
        external_id: shopifyOrder.customer.id,
        email: shopifyOrder.customer.email,
        name: `${shopifyOrder.customer.first_name} ${shopifyOrder.customer.last_name}`
      },
      billing_address: shopifyOrder.billing_address,
      shipping_address: shopifyOrder.shipping_address,
      line_items: shopifyOrder.line_items.map(item => ({
        sku: item.sku,
        quantity: item.quantity,
        price: parseFloat(item.price),
        title: item.title
      })),
      total_amount: parseFloat(shopifyOrder.total_price),
      currency: shopifyOrder.currency,
      order_date: shopifyOrder.created_at,
      payment_status: shopifyOrder.financial_status,
      fulfillment_status: shopifyOrder.fulfillment_status
    }
  }
}

// 3PL智能物流管理
class ThirdPartyLogistics {
  constructor() {
    this.providers = {
      'fulfillment_provider_1': {
        endpoint: 'https://api.provider1.com',
        apiKey: process.env.PROVIDER1_API_KEY,
        specialties: ['electronics', 'fragile'],
        regions: ['US', 'CA']
      },
      'fulfillment_provider_2': {
        endpoint: 'https://api.provider2.com',
        apiKey: process.env.PROVIDER2_API_KEY,
        specialties: ['apparel', 'books'],
        regions: ['EU', 'UK']
      }
    }
  }
 
  async routeOrder(order) {
    const optimalProvider = await this.selectOptimalProvider(order)
    
    if (!optimalProvider) {
      throw new Error('No suitable fulfillment provider found')
    }
    
    return await this.sendOrderToProvider(order, optimalProvider)
  }
 
  async selectOptimalProvider(order) {
    const shippingCountry = order.shipping_address.country_code
    const productTypes = order.line_items.map(item => item.product_type)
    
    const suitableProviders = Object.entries(this.providers).filter(([key, provider]) => {
      // 检查地区覆盖
      const regionMatch = provider.regions.includes(shippingCountry)
      
      // 检查产品类型专长
      const specialtyMatch = productTypes.some(type => 
        provider.specialties.includes(type.toLowerCase())
      )
      
      return regionMatch && specialtyMatch
    })
    
    if (suitableProviders.length === 0) {
      return null
    }
    
    // 选择最优提供商（基于成本、时效等因素）
    const providerScores = await Promise.all(
      suitableProviders.map(async ([key, provider]) => {
        const quote = await this.getShippingQuote(provider, order)
        return {
          provider: key,
          config: provider,
          score: this.calculateProviderScore(quote, order),
          quote
        }
      })
    )
    
    return providerScores.reduce((best, current) => 
      current.score > best.score ? current : best
    )
  }
 
  calculateProviderScore(quote, order) {
    const costWeight = 0.4
    const speedWeight = 0.3
    const reliabilityWeight = 0.3
    
    // 成本分数（成本越低分数越高）
    const costScore = Math.max(0, 100 - (quote.cost / order.total_price * 100))
    
    // 速度分数（交货时间越短分数越高）
    const speedScore = Math.max(0, 100 - quote.estimated_days * 10)
    
    // 可靠性分数（基于历史表现）
    const reliabilityScore = quote.provider_rating || 80
    
    return (costScore * costWeight) + (speedScore * speedWeight) + (reliabilityScore * reliabilityWeight)
  }
 
  async sendOrderToProvider(order, provider) {
    const fulfillmentRequest = {
      order_id: order.id,
      order_number: order.name,
      shipping_address: order.shipping_address,
      items: order.line_items.map(item => ({
        sku: item.sku,
        quantity: item.quantity,
        description: item.title
      })),
      shipping_method: order.shipping_lines[0]?.code,
      special_instructions: order.note || ''
    }
    
    const response = await fetch(`${provider.config.endpoint}/fulfillments`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${provider.config.apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(fulfillmentRequest)
    })
    
    if (!response.ok) {
      throw new Error(`Fulfillment request failed: ${response.statusText}`)
    }
    
    const fulfillmentResponse = await response.json()
    
    // 创建Shopify履约记录
    await this.createShopifyFulfillment(order.id, {
      location_id: null,
      tracking_number: fulfillmentResponse.tracking_number,
      tracking_company: fulfillmentResponse.carrier,
      notify_customer: true,
      line_items: order.line_items.map(item => ({
        id: item.id,
        quantity: item.quantity
      }))
    })
    
    return fulfillmentResponse
  }
 
  async handleFulfillmentWebhook(providerName, webhookData) {
    const provider = this.providers[providerName]
    
    if (!provider) {
      throw new Error(`Unknown provider: ${providerName}`)
    }
    
    switch (webhookData.event_type) {
      case 'fulfillment_shipped':
        await this.updateShipmentTracking(webhookData)
        break
        
      case 'fulfillment_delivered':
        await this.markOrderDelivered(webhookData)
        break
        
      case 'fulfillment_exception':
        await this.handleFulfillmentException(webhookData)
        break
        
      default:
        console.log(`Unhandled webhook event: ${webhookData.event_type}`)
    }
  }
}