n8n 企业级集成指南：连接你的业务生态系统

网站表单 → Webhook 触发器 → 数据验证 → Salesforce 创建线索 → 通知销售团队

// Salesforce OAuth2 配置
{
  "clientId": "your_client_id",
  "clientSecret": "your_client_secret",
  "loginUrl": "https://login.salesforce.com"
}

// Function 节点：数据转换
function transformLeadData(webformData) {
  return {
    FirstName: webformData.firstName,
    LastName: webformData.lastName,
    Email: webformData.email,
    Company: webformData.company,
    LeadSource: 'Website',
    Status: 'New'
  };
}

return transformLeadData($json);

// Salesforce 节点设置
{
  "operation": "create",
  "resource": "lead",
  "fields": {
    "FirstName": "={{$json.FirstName}}",
    "LastName": "={{$json.LastName}}",
    "Email": "={{$json.Email}}",
    "Company": "={{$json.Company}}",
    "LeadSource": "={{$json.LeadSource}}"
  }
}

HubSpot 联系人更新 → n8n 触发器 → 数据转换 → 同步到内部 CRM → 记录同步日志

Shopify 新订单 → 库存检查 → 发货通知 → 客户服务更新 → 财务系统记录

// Shopify Webhook 处理
{
  "trigger": "Shopify Trigger",
  "event": "orders/paid",
  "webhook_url": "https://your-n8n-instance.com/webhook/shopify-orders"
}

// 订单数据处理
function processOrder(orderData) {
  return {
    orderId: orderData.id,
    customerEmail: orderData.email,
    totalAmount: orderData.total_price,
    items: orderData.line_items.map(item => ({
      productId: item.product_id,
      quantity: item.quantity,
      price: item.price
    })),
    shippingAddress: orderData.shipping_address
  };
}

WooCommerce 库存变更 → ERP 系统更新 → 多渠道库存同步 → 低库存预警

用户行为数据 → 用户画像分析 → Mailchimp 列表分段 → 个性化邮件发送 → 效果跟踪

// 用户分段逻辑
function segmentUsers(userData) {
  const segments = [];

  if (userData.totalPurchases > 1000) {
    segments.push('VIP_CUSTOMERS');
  }

  if (userData.lastPurchaseDate > 30) {
    segments.push('INACTIVE_CUSTOMERS');
  }

  if (userData.productInterests.includes('tech')) {
    segments.push('TECH_ENTHUSIASTS');
  }

  return segments;
}

// Mailchimp 批量操作
{
  "operation": "upsertMember",
  "list": "your_list_id",
  "email": "={{$json.email}}",
  "tags": "={{$json.segments}}",
  "mergeFields": {
    "FNAME": "={{$json.firstName}}",
    "LNAME": "={{$json.lastName}}",
    "PURCHASES": "={{$json.totalPurchases}}"
  }
}

客户支持工单 → 问题分类 → Jira 任务创建 → 开发团队分配 → 进度通知

// 工单分类逻辑
function categorizeTicket(ticket) {
  const keywords = {
    'bug': ['error', 'crash', 'broken', 'not working'],
    'feature': ['request', 'enhancement', 'improvement'],
    'documentation': ['help', 'how to', 'tutorial']
  };

  const content = (ticket.subject + ' ' + ticket.description).toLowerCase();

  for (const [category, words] of Object.entries(keywords)) {
    if (words.some(word => content.includes(word))) {
      return category;
    }
  }

  return 'general';
}

// Jira 任务创建
{
  "operation": "create",
  "resource": "issue",
  "fields": {
    "project": { "key": "SUPPORT" },
    "summary": "={{$json.subject}}",
    "description": "={{$json.description}}",
    "issuetype": { "name": "Task" },
    "priority": { "name": "Medium" }
  }
}

销售机会 → 项目创建 → 任务分配 → 进度跟踪 → 完成通知

销售订单 → 发票生成 → 付款跟踪 → 会计记录 → 财务报告

// 发票数据准备
function prepareInvoiceData(orderData) {
  return {
    customer: {
      name: orderData.customerName,
      email: orderData.customerEmail
    },
    line_items: orderData.items.map(item => ({
      description: item.name,
      quantity: item.quantity,
      unit_price: item.price,
      amount: item.quantity * item.price
    })),
    due_date: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000), // 30天后
    terms: "Net 30"
  };
}

多个数据源 → 数据提取 → 数据转换 → 数据质量检查 → 数据湖存储 → 分析平台

// 数据提取调度器
const dataSources = [
  { name: 'salesforce', endpoint: '/api/leads', frequency: '0 */4 * * *' },
  { name: 'shopify', endpoint: '/api/orders', frequency: '0 */2 * * *' },
  { name: 'mailchimp', endpoint: '/api/campaigns', frequency: '0 0 * * *' }
];

// 数据转换标准化
function standardizeData(source, rawData) {
  const standardized = {
    source: source,
    timestamp: new Date().toISOString(),
    data: null,
    metadata: {
      recordCount: rawData.length,
      processedAt: new Date().toISOString()
    }
  };

  switch (source) {
    case 'salesforce':
      standardized.data = rawData.map(lead => ({
        id: lead.Id,
        email: lead.Email,
        name: `${lead.FirstName} ${lead.LastName}`,
        source: 'crm'
      }));
      break;
    // 其他数据源的处理逻辑
  }

  return standardized;
}

事件发布者 → 事件总线 → 事件订阅者 → 业务处理 → 状态更新

// API 路由配置
const apiRoutes = {
  '/api/customer': {
    method: 'POST',
    workflow: 'customer-management',
    rateLimit: '100/hour'
  },
  '/api/order': {
    method: 'POST',
    workflow: 'order-processing',
    rateLimit: '500/hour'
  }
};

// 统一错误处理
function handleApiError(error, context) {
  const errorResponse = {
    error: true,
    message: error.message,
    code: error.code || 'INTERNAL_ERROR',
    timestamp: new Date().toISOString(),
    requestId: context.executionId
  };

  // 记录错误日志
  console.error('API Error:', JSON.stringify(errorResponse));

  return errorResponse;
}

// 数据加密工具函数
const crypto = require('crypto');

function encryptSensitiveData(data, encryptionKey) {
  const algorithm = 'aes-256-gcm';
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipher(algorithm, encryptionKey, iv);

  let encrypted = cipher.update(JSON.stringify(data), 'utf8', 'hex');
  encrypted += cipher.final('hex');

  return {
    encryptedData: encrypted,
    iv: iv.toString('hex'),
    tag: cipher.getAuthTag().toString('hex')
  };
}

// 权限检查中间件
function checkPermissions(userRole, requiredPermission) {
  const rolePermissions = {
    'admin': ['read', 'write', 'delete', 'manage'],
    'user': ['read', 'write'],
    'viewer': ['read']
  };

  return rolePermissions[userRole]?.includes(requiredPermission) || false;
}

// 审计日志记录
function logAuditEvent(action, userId, resourceId, details) {
  const auditEvent = {
    timestamp: new Date().toISOString(),
    action: action,
    userId: userId,
    resourceId: resourceId,
    details: details,
    ipAddress: $execution.context?.ipAddress,
    userAgent: $execution.context?.userAgent
  };

  // 发送到审计日志系统
  return auditEvent;
}

// 健康检查工作流
async function healthCheck() {
  const services = [
    { name: 'Salesforce', url: 'https://api.salesforce.com/health' },
    { name: 'Shopify', url: 'https://api.shopify.com/health' },
    { name: 'Mailchimp', url: 'https://api.mailchimp.com/ping' }
  ];

  const results = await Promise.all(
    services.map(async (service) => {
      try {
        const response = await fetch(service.url);
        return {
          service: service.name,
          status: response.ok ? 'healthy' : 'unhealthy',
          responseTime: response.headers.get('x-response-time')
        };
      } catch (error) {
        return {
          service: service.name,
          status: 'error',
          error: error.message
        };
      }
    })
  );

  return results;
}

// 性能指标收集
function collectMetrics(workflowName, startTime, endTime, recordCount) {
  const metrics = {
    workflow: workflowName,
    executionTime: endTime - startTime,
    recordsProcessed: recordCount,
    recordsPerSecond: recordCount / ((endTime - startTime) / 1000),
    timestamp: new Date().toISOString()
  };

  // 发送到监控系统
  sendToMonitoringSystem(metrics);

  return metrics;
}

Shopify → n8n → [Salesforce, Mailchimp, Slack, Sheets, QuickBooks]

Shopify新订单 → 客户信息同步到Salesforce → 发送确认邮件 → 库存更新 → 财务记录 → Slack通知

新客户注册 → Mailchimp欢迎序列 → Salesforce客户档案 → 个性化推荐 → 满意度调研

每日销售数据收集 → 数据清洗转换 → Google Sheets报告 → 管理层邮件推送