WordPress文创产品柔性供应链插件配置与使用教程

一、插件概述与安装准备

1.1 什么是柔性供应链插件

柔性供应链插件是专为文创产品电商设计的WordPress扩展工具，它能够帮助文创企业实现：

• 多供应商协同管理
• 动态库存调整
• 智能订单分配
• 生产进度跟踪
• 物流状态监控

1.2 系统环境要求

在安装插件前，请确保您的WordPress环境满足以下要求：

• WordPress 5.6或更高版本
• PHP 7.4或更高版本
• MySQL 5.6或更高版本
• 至少256MB PHP内存限制
• HTTPS支持（推荐）

1.3 插件安装步骤

/**
 * 插件安装函数示例
 * 此代码展示插件激活时的初始化操作
 */

// 定义插件激活时的操作
function cultural_product_supply_chain_activate() {
    // 检查WordPress版本
    global $wp_version;
    $min_wp_version = '5.6';
    
    if (version_compare($wp_version, $min_wp_version, '<')) {
        wp_die('此插件需要WordPress ' . $min_wp_version . ' 或更高版本');
    }
    
    // 创建必要的数据库表
    create_supply_chain_tables();
    
    // 设置默认选项
    $default_options = array(
        'auto_allocate_orders' => true,
        'low_stock_threshold' => 10,
        'supplier_notification' => true,
        'sync_frequency' => 'hourly'
    );
    
    add_option('cultural_supply_chain_settings', $default_options);
    
    // 创建定时任务
    if (!wp_next_scheduled('sync_supplier_inventory')) {
        wp_schedule_event(time(), 'hourly', 'sync_supplier_inventory');
    }
}

// 注册激活钩子
register_activation_hook(__FILE__, 'cultural_product_supply_chain_activate');

二、插件基础配置

2.1 供应商管理设置

进入WordPress后台，找到"文创供应链"菜单，点击"供应商管理"：

/**
 * 供应商管理类示例
 * 处理供应商信息的增删改查
 */

class SupplierManager {
    private $db;
    
    public function __construct() {
        global $wpdb;
        $this->db = $wpdb;
        $this->table_name = $wpdb->prefix . 'cultural_suppliers';
    }
    
    /**
     * 添加新供应商
     * @param array $supplier_data 供应商数据
     * @return int|false 插入ID或false
     */
    public function add_supplier($supplier_data) {
        $defaults = array(
            'name' => '',
            'contact_person' => '',
            'email' => '',
            'phone' => '',
            'address' => '',
            'production_capacity' => 100,
            'lead_time' => 7, // 默认交货期7天
            'status' => 'active',
            'created_at' => current_time('mysql')
        );
        
        $data = wp_parse_args($supplier_data, $defaults);
        
        // 数据验证
        if (empty($data['name']) || !is_email($data['email'])) {
            return false;
        }
        
        // 插入数据库
        $result = $this->db->insert(
            $this->table_name,
            $data,
            array('%s', '%s', '%s', '%s', '%s', '%d', '%d', '%s', '%s')
        );
        
        return $result ? $this->db->insert_id : false;
    }
    
    /**
     * 获取所有活跃供应商
     * @return array 供应商列表
     */
    public function get_active_suppliers() {
        $query = $this->db->prepare(
            "SELECT * FROM {$this->table_name} WHERE status = %s ORDER BY name ASC",
            'active'
        );
        
        return $this->db->get_results($query);
    }
}

2.2 产品与供应商关联配置

/**
 * 产品-供应商关联管理
 */

class ProductSupplierLink {
    
    /**
     * 为产品分配供应商
     * @param int $product_id 产品ID
     * @param int $supplier_id 供应商ID
     * @param array $params 分配参数
     */
    public function assign_supplier_to_product($product_id, $supplier_id, $params = array()) {
        global $wpdb;
        
        $table_name = $wpdb->prefix . 'cultural_product_suppliers';
        
        $default_params = array(
            'priority' => 1, // 优先级，数字越小优先级越高
            'allocation_percentage' => 100, // 分配百分比
            'min_order_quantity' => 1,
            'unit_cost' => 0.00,
            'is_primary' => false
        );
        
        $params = wp_parse_args($params, $default_params);
        
        // 检查是否已存在关联
        $existing = $wpdb->get_var($wpdb->prepare(
            "SELECT COUNT(*) FROM {$table_name} 
             WHERE product_id = %d AND supplier_id = %d",
            $product_id, $supplier_id
        ));
        
        if ($existing > 0) {
            // 更新现有记录
            return $wpdb->update(
                $table_name,
                $params,
                array('product_id' => $product_id, 'supplier_id' => $supplier_id),
                array('%d', '%d', '%d', '%f', '%d'),
                array('%d', '%d')
            );
        } else {
            // 插入新记录
            $data = array_merge(
                array('product_id' => $product_id, 'supplier_id' => $supplier_id),
                $params
            );
            
            return $wpdb->insert(
                $table_name,
                $data,
                array('%d', '%d', '%d', '%d', '%d', '%f', '%d')
            );
        }
    }
}

三、库存与订单管理

3.1 智能库存同步系统

/**
 * 库存同步管理器
 * 处理多供应商库存同步
 */

class InventorySyncManager {
    
    /**
     * 同步所有供应商库存
     */
    public function sync_all_suppliers_inventory() {
        $supplier_manager = new SupplierManager();
        $suppliers = $supplier_manager->get_active_suppliers();
        
        $results = array();
        
        foreach ($suppliers as $supplier) {
            $result = $this->sync_supplier_inventory($supplier->id);
            $results[$supplier->id] = $result;
        }
        
        // 记录同步日志
        $this->log_sync_results($results);
        
        return $results;
    }
    
    /**
     * 同步单个供应商库存
     * @param int $supplier_id 供应商ID
     */
    private function sync_supplier_inventory($supplier_id) {
        // 获取供应商API配置
        $api_config = $this->get_supplier_api_config($supplier_id);
        
        if (!$api_config || empty($api_config['api_url'])) {
            return array('success' => false, 'error' => 'API配置缺失');
        }
        
        // 调用供应商API获取库存数据
        $inventory_data = $this->call_supplier_api($api_config);
        
        if (is_wp_error($inventory_data)) {
            return array('success' => false, 'error' => $inventory_data->get_error_message());
        }
        
        // 更新本地库存记录
        $updated = $this->update_local_inventory($supplier_id, $inventory_data);
        
        return array(
            'success' => true,
            'updated_count' => $updated,
            'timestamp' => current_time('mysql')
        );
    }
    
    /**
     * 更新本地库存
     */
    private function update_local_inventory($supplier_id, $inventory_data) {
        global $wpdb;
        $table_name = $wpdb->prefix . 'cultural_inventory';
        
        $updated = 0;
        
        foreach ($inventory_data as $item) {
            $result = $wpdb->replace(
                $table_name,
                array(
                    'supplier_id' => $supplier_id,
                    'product_sku' => sanitize_text_field($item['sku']),
                    'quantity' => intval($item['quantity']),
                    'reserved' => intval($item['reserved']),
                    'available' => intval($item['quantity']) - intval($item['reserved']),
                    'last_synced' => current_time('mysql')
                ),
                array('%d', '%s', '%d', '%d', '%d', '%s')
            );
            
            if ($result !== false) {
                $updated++;
            }
        }
        
        return $updated;
    }
}

3.2 订单智能分配算法

/**
 * 订单分配引擎
 * 根据预设规则自动分配订单给供应商
 */

class OrderAllocationEngine {
    
    /**
     * 分配订单给供应商
     * @param WC_Order $order WooCommerce订单对象
     * @return array 分配结果
     */
    public function allocate_order($order) {
        $order_items = $order->get_items();
        $allocation_results = array();
        
        foreach ($order_items as $item) {
            $product_id = $item->get_product_id();
            $quantity = $item->get_quantity();
            
            // 获取可用的供应商
            $available_suppliers = $this->get_available_suppliers($product_id, $quantity);
            
            if (empty($available_suppliers)) {
                // 如果没有可用供应商，标记为需要手动处理
                $allocation_results[$product_id] = array(
                    'status' => 'manual_review',
                    'message' => '没有足够的库存或可用供应商'
                );
                continue;
            }
            
            // 应用分配策略
            $selected_supplier = $this->apply_allocation_strategy(
                $available_suppliers, 
                $product_id, 
                $quantity
            );
            
            if ($selected_supplier) {
                // 创建分配记录
                $allocation_id = $this->create_allocation_record(
                    $order->get_id(),
                    $product_id,
                    $selected_supplier['supplier_id'],
                    $quantity
                );
                
                $allocation_results[$product_id] = array(
                    'status' => 'allocated',
                    'supplier_id' => $selected_supplier['supplier_id'],
                    'supplier_name' => $selected_supplier['name'],
                    'allocation_id' => $allocation_id,
                    'quantity' => $quantity
                );
            }
        }
        
        return $allocation_results;
    }
    
    /**
     * 应用分配策略
     * 支持多种策略：优先级、成本最优、交货最快等
     */
    private function apply_allocation_strategy($suppliers, $product_id, $quantity) {
        $strategy = get_option('cultural_allocation_strategy', 'priority_based');
        
        switch ($strategy) {
            case 'cost_based':
                // 成本最优策略
                usort($suppliers, function($a, $b) {
                    return $a['unit_cost'] <=> $b['unit_cost'];
                });
                break;
                
            case 'fastest_delivery':
                // 最快交货策略
                usort($suppliers, function($a, $b) {
                    return $a['lead_time'] <=> $b['lead_time'];
                });
                break;
                
            case 'priority_based':
            default:
                // 基于优先级策略（默认）
                usort($suppliers, function($a, $b) {
                    if ($a['priority'] == $b['priority']) {
                        return $a['lead_time'] <=> $b['lead_time'];
                    }
                    return $a['priority'] <=> $b['priority'];
                });
                break;
        }
        
        return !empty($suppliers) ? $suppliers[0] : null;
    }
}

四、高级功能与自定义

4.1 Webhook集成配置

/**
 * Webhook处理器
 * 用于与外部系统集成
 */

class SupplyChainWebhookHandler {
    
    /**
     * 注册Webhook端点
     */
    public function register_webhooks() {
        // 库存更新Webhook
        add_action('rest_api_init', function() {
            register_rest_route('cultural-supply/v1', '/inventory-update', array(
                'methods' => 'POST',
                'callback' => array($this, 'handle_inventory_update'),
                'permission_callback' => array($this, 'verify_webhook_signature')
            ));
            
            // 订单状态更新Webhook
            register_rest_route('cultural-supply/v1', '/order-status-update', array(
                'methods' => 'POST',
                'callback' => array($this, 'handle_order_status_update'),
                'permission_callback' => array($this, 'verify_webhook_signature')
            ));
        });
    }
    
    /**
     * 处理库存更新Webhook
     */
    public function handle_inventory_update(WP_REST_Request $request) {
        $data = $request->get_json_params();
        
        // 验证必要字段
        $required_fields = ['supplier_id', 'sku', 'quantity', 'timestamp'];
        foreach ($required_fields as $field) {
            if (!isset($data[$field])) {
                return new WP_REST_Response(
                    array('error' => "缺少必要字段: {$field}"),
                    400
                );
            }
        }
        
        // 更新库存
        $inventory_manager = new InventorySyncManager();
        $result = $inventory_manager->update_single_inventory(
            $data['supplier_id'],
            $data['sku'],
            $data['quantity']
        );
        
        if ($result['success']) {
            return new WP_REST_Response(
                array('message' => '库存更新成功', 'data' => $result),
                200
            );
        } else {
            return new WP_REST_Response(
                array('error' => '库存更新失败', 'details' => $result),
                500
            );
        }
    }
    
    /**
     * 验证Webhook签名
     */
    public function verify_webhook_signature(WP_REST_Request $request) {
        $secret_key = get_option('cultural_webhook_secret');
        
        if (empty($secret_key)) {
            return false;
        }
        
        $signature = $request->get_header('X-Cultural-Signature');
        $payload = $request->get_body();
        
        $expected_signature = hash_hmac('sha256', $payload, $secret_key);
        
        return hash_equals($expected_signature, $signature);
    }
}

4.2 自定义分配规则

/**
 * 自定义分配规则引擎
 * 允许用户创建复杂的分配规则
 */

class CustomAllocationRuleEngine {
    
    /**
     * 评估自定义规则
     * @param array $rule 规则配置
     * @param array $context 评估上下文
     * @return bool 是否匹配规则
     */
    public function evaluate_rule($rule, $context) {
        if (empty($rule['conditions'])) {
            return true;
        }
        
        $conditions_met = true;
        
        foreach ($rule['conditions'] as $condition) {
            if (!$this->evaluate_condition($condition, $context)) {
                $conditions_met = false;
                break;
            }
        }
        
        return $conditions_met;
    }
    
    /**
     * 评估单个条件
     */
    private function evaluate_condition($condition, $context) {
        $field_value = $this->get_field_value($condition['field'], $context);
        
        switch ($condition['operator']) {
            case 'equals':
                return $field_value == $condition['value'];
                
            case 'not_equals':
                return $field_value != $condition['value'];
                
            case 'greater_than':
                return $field_value > $condition['value'];
                
            case 'less_than':
                return $field_value < $condition['value'];
                
            case 'contains':
                return stripos($field_value, $condition['value']) !== false;
                
            case 'in':
                return in_array($field_value, (array)$condition['value']);
                
            default:
                return false;
        }
    }
    
    /**
     * 应用规则到订单分配
     */
    public function apply_rules_to_allocation($suppliers, $order_context) {
        $rules = $this->get_active_rules();
        $filtered_suppliers = array();
        
        foreach ($suppliers as $supplier) {
            $context = array_merge($order_context, array('supplier' => $supplier));
            $rule_applied = false;
            
            foreach ($rules as $rule) {
                if ($this->evaluate_rule($rule, $context)) {
                    // 应用规则操作
                    $supplier = $this->apply_rule_actions($supplier, $rule['actions']);
                    $rule_applied = true;
                    
                    // 如果规则设置了停止进一步评估，则跳出循环
                    if (!empty($rule['stop_evaluation'])) {
                        break;
                    }
                }
            }
            
            if ($rule_applied || empty($rules)) {
                $filtered_suppliers[] = $supplier;
            }
        }
        
        return $filtered_suppliers;
    }
}

五、故障排除与优化建议

5.1 常见问题解决

1. 库存同步失败

   • 检查供应商API配置
   • 验证API密钥和权限
   • 查看错误日志定位问题

2. 订单分配异常

   • 验证供应商状态是否活跃
   • 检查库存数量是否充足
   • 查看分配规则配置

3. 性能优化建议

   • 启用数据缓存
   • 优化数据库查询
   • 设置合理的同步频率

5.2 最佳实践

1. 定期维护

   • 每月清理旧日志

• 每季度审核供应商绩效

  • 更新插件到最新版本

2. 数据备份策略

   • 每日备份供应链数据
   • 测试备份恢复流程
   • 保留30天操作日志

3. 供应商管理

   • 建立供应商评估体系
   • 维护备用供应商列表
   • 定期沟通同步需求变化

六、监控与报表系统

6.1 实时监控面板

/**
 * 供应链监控面板
 * 提供实时数据可视化
 */

class SupplyChainDashboard {
    
    /**
     * 生成监控面板数据
     */
    public function get_dashboard_data() {
        return array(
            'inventory_summary' => $this->get_inventory_summary(),
            'order_allocations' => $this->get_recent_allocations(),
            'supplier_performance' => $this->get_supplier_performance(),
            'system_health' => $this->get_system_health()
        );
    }
    
    /**
     * 获取库存摘要
     */
    private function get_inventory_summary() {
        global $wpdb;
        
        $query = "
            SELECT 
                COUNT(DISTINCT product_sku) as total_products,
                SUM(available) as total_available,
                SUM(CASE WHEN available <= low_stock_threshold THEN 1 ELSE 0 END) as low_stock_items,
                AVG(last_synced <= DATE_SUB(NOW(), INTERVAL 1 DAY)) as sync_freshness
            FROM {$wpdb->prefix}cultural_inventory
            WHERE available > 0
        ";
        
        return $wpdb->get_row($query, ARRAY_A);
    }
    
    /**
     * 获取供应商绩效数据
     */
    private function get_supplier_performance($days = 30) {
        global $wpdb;
        
        $query = $wpdb->prepare("
            SELECT 
                s.name,
                s.id,
                COUNT(DISTINCT oa.order_id) as total_orders,
                AVG(TIMESTAMPDIFF(HOUR, oa.created_at, os.completed_at)) as avg_fulfillment_hours,
                SUM(CASE WHEN os.status = 'delayed' THEN 1 ELSE 0 END) as delayed_orders,
                (SUM(CASE WHEN os.status = 'completed' THEN 1 ELSE 0 END) / COUNT(*)) * 100 as completion_rate
            FROM {$wpdb->prefix}cultural_order_allocations oa
            LEFT JOIN {$wpdb->prefix}cultural_order_status os ON oa.id = os.allocation_id
            LEFT JOIN {$wpdb->prefix}cultural_suppliers s ON oa.supplier_id = s.id
            WHERE oa.created_at >= DATE_SUB(NOW(), INTERVAL %d DAY)
            GROUP BY s.id
            ORDER BY completion_rate DESC
            LIMIT 10
        ", $days);
        
        return $wpdb->get_results($query, ARRAY_A);
    }
}

6.2 自定义报表生成

/**
 * 报表生成器
 * 支持导出Excel、PDF等格式
 */

class SupplyChainReportGenerator {
    
    /**
     * 生成库存报表
     */
    public function generate_inventory_report($params = array()) {
        $defaults = array(
            'report_type' => 'detailed',
            'format' => 'csv',
            'date_range' => 'month',
            'supplier_id' => null,
            'category_id' => null
        );
        
        $params = wp_parse_args($params, $defaults);
        
        // 获取数据
        $data = $this->get_inventory_report_data($params);
        
        // 根据格式生成报表
        switch ($params['format']) {
            case 'excel':
                return $this->generate_excel_report($data, '库存报表');
            case 'pdf':
                return $this->generate_pdf_report($data, '库存报表');
            case 'csv':
            default:
                return $this->generate_csv_report($data);
        }
    }
    
    /**
     * 生成CSV报表
     */
    private function generate_csv_report($data) {
        $output = fopen('php://output', 'w');
        
        // 添加BOM头，支持中文
        fwrite($output, "xEFxBBxBF");
        
        // 写入标题行
        if (!empty($data['headers'])) {
            fputcsv($output, $data['headers']);
        }
        
        // 写入数据行
        foreach ($data['rows'] as $row) {
            fputcsv($output, $row);
        }
        
        fclose($output);
        
        // 设置HTTP头
        header('Content-Type: text/csv; charset=utf-8');
        header('Content-Disposition: attachment; filename="inventory_report_' . date('Ymd') . '.csv"');
        
        return true;
    }
    
    /**
     * 获取报表数据
     */
    private function get_inventory_report_data($params) {
        global $wpdb;
        
        $where_clauses = array('1=1');
        $query_params = array();
        
        // 构建查询条件
        if (!empty($params['supplier_id'])) {
            $where_clauses[] = 'i.supplier_id = %d';
            $query_params[] = $params['supplier_id'];
        }
        
        if (!empty($params['date_range'])) {
            $date_condition = $this->get_date_range_condition($params['date_range']);
            $where_clauses[] = $date_condition;
        }
        
        $where_sql = implode(' AND ', $where_clauses);
        
        $query = "
            SELECT 
                s.name as supplier_name,
                p.post_title as product_name,
                i.product_sku,
                i.quantity,
                i.reserved,
                i.available,
                i.low_stock_threshold,
                i.last_synced,
                CASE 
                    WHEN i.available <= i.low_stock_threshold THEN '低库存'
                    WHEN i.available = 0 THEN '缺货'
                    ELSE '充足'
                END as stock_status
            FROM {$wpdb->prefix}cultural_inventory i
            LEFT JOIN {$wpdb->prefix}cultural_suppliers s ON i.supplier_id = s.id
            LEFT JOIN {$wpdb->prefix}posts p ON i.product_id = p.ID
            WHERE {$where_sql}
            ORDER BY i.available ASC, i.last_synced DESC
        ";
        
        if (!empty($query_params)) {
            $query = $wpdb->prepare($query, $query_params);
        }
        
        $results = $wpdb->get_results($query, ARRAY_A);
        
        return array(
            'headers' => array('供应商', '产品名称', 'SKU', '总库存', '预留', '可用', '低库存阈值', '最后同步', '库存状态'),
            'rows' => $results
        );
    }
}

七、API接口文档

7.1 REST API端点

/**
 * 供应链REST API
 * 提供外部系统集成接口
 */

class SupplyChainRESTAPI {
    
    public function register_routes() {
        register_rest_route('cultural-supply/v1', '/suppliers', array(
            array(
                'methods' => 'GET',
                'callback' => array($this, 'get_suppliers'),
                'permission_callback' => array($this, 'check_api_permission'),
                'args' => array(
                    'status' => array(
                        'required' => false,
                        'default' => 'active',
                        'validate_callback' => function($param) {
                            return in_array($param, array('active', 'inactive', 'all'));
                        }
                    ),
                    'page' => array(
                        'required' => false,
                        'default' => 1,
                        'validate_callback' => function($param) {
                            return is_numeric($param) && $param > 0;
                        }
                    ),
                    'per_page' => array(
                        'required' => false,
                        'default' => 20,
                        'validate_callback' => function($param) {
                            return is_numeric($param) && $param > 0 && $param <= 100;
                        }
                    )
                )
            ),
            array(
                'methods' => 'POST',
                'callback' => array($this, 'create_supplier'),
                'permission_callback' => array($this, 'check_api_permission')
            )
        ));
        
        register_rest_route('cultural-supply/v1', '/inventory/(?P<sku>[a-zA-Z0-9-_]+)', array(
            'methods' => 'GET',
            'callback' => array($this, 'get_inventory_by_sku'),
            'permission_callback' => array($this, 'check_api_permission'),
            'args' => array(
                'sku' => array(
                    'required' => true,
                    'validate_callback' => function($param) {
                        return !empty($param) && strlen($param) <= 50;
                    }
                )
            )
        ));
    }
    
    /**
     * 获取供应商列表
     */
    public function get_suppliers(WP_REST_Request $request) {
        $params = $request->get_params();
        
        $supplier_manager = new SupplierManager();
        
        $args = array(
            'status' => $params['status'],
            'page' => $params['page'],
            'per_page' => $params['per_page']
        );
        
        $suppliers = $supplier_manager->get_suppliers($args);
        $total = $supplier_manager->count_suppliers($args);
        
        $response = new WP_REST_Response($suppliers);
        $response->header('X-Total-Count', $total);
        $response->header('X-Total-Pages', ceil($total / $params['per_page']));
        
        return $response;
    }
    
    /**
     * 根据SKU获取库存信息
     */
    public function get_inventory_by_sku(WP_REST_Request $request) {
        $sku = $request->get_param('sku');
        
        global $wpdb;
        
        $query = $wpdb->prepare("
            SELECT 
                i.*,
                s.name as supplier_name,
                s.lead_time,
                p.post_title as product_name
            FROM {$wpdb->prefix}cultural_inventory i
            LEFT JOIN {$wpdb->prefix}cultural_suppliers s ON i.supplier_id = s.id
            LEFT JOIN {$wpdb->prefix}posts p ON i.product_id = p.ID
            WHERE i.product_sku = %s
            ORDER BY i.available DESC
        ", $sku);
        
        $results = $wpdb->get_results($query, ARRAY_A);
        
        if (empty($results)) {
            return new WP_Error(
                'not_found',
                '未找到该SKU的库存信息',
                array('status' => 404)
            );
        }
        
        // 计算总可用库存
        $total_available = array_sum(array_column($results, 'available'));
        
        return array(
            'sku' => $sku,
            'total_available' => $total_available,
            'suppliers' => $results,
            'timestamp' => current_time('mysql')
        );
    }
    
    /**
     * 检查API权限
     */
    public function check_api_permission(WP_REST_Request $request) {
        // 检查API密钥
        $api_key = $request->get_header('X-API-Key');
        
        if (empty($api_key)) {
            return new WP_Error(
                'rest_forbidden',
                '缺少API密钥',
                array('status' => 401)
            );
        }
        
        // 验证API密钥
        $valid_keys = get_option('cultural_api_keys', array());
        
        if (!in_array($api_key, $valid_keys)) {
            return new WP_Error(
                'rest_forbidden',
                '无效的API密钥',
                array('status' => 403)
            );
        }
        
        return true;
    }
}

八、安全与性能优化

8.1 安全加固措施

/**
 * 安全增强模块
 */

class SupplyChainSecurity {
    
    /**
     * 初始化安全设置
     */
    public function init_security() {
        // 防止SQL注入
        add_filter('query', array($this, 'sanitize_queries'));
        
        // 验证用户输入
        add_action('init', array($this, 'validate_inputs'));
        
        // 设置API访问限制
        $this->setup_api_limits();
        
        // 记录安全日志
        add_action('cultural_security_event', array($this, 'log_security_event'));
    }
    
    /**
     * 数据输入验证
     */
    public function validate_inputs() {
        if ($_SERVER['REQUEST_METHOD'] === 'POST') {
            $this->validate_post_data();
        }
    }
    
    /**
     * 验证POST数据
     */
    private function validate_post_data() {
        $allowed_fields = array(
            'supplier_name' => 'text',
            'email' => 'email',
            'phone' => 'phone',
            'quantity' => 'int',
            'price' => 'float'
        );
        
        foreach ($_POST as $key => $value) {
            if (isset($allowed_fields[$key])) {
                $this->sanitize_field($key, $value, $allowed_fields[$key]);
            }
        }
    }
    
    /**
     * 字段清理
     */
    private function sanitize_field($key, $value, $type) {
        switch ($type) {
            case 'text':
                return sanitize_text_field($value);
            case 'email':
                return sanitize_email($value);
            case 'int':
                return intval($value);
            case 'float':
                return floatval($value);
            case 'phone':
                return preg_replace('/[^0-9+-s]/', '', $value);
            default:
                return sanitize_text_field($value);
        }
    }
    
    /**
     * 设置API访问限制
     */
    private function setup_api_limits() {
        add_filter('rest_pre_dispatch', array($this, 'check_api_rate_limit'), 10, 3);
    }
    
    /**
     * 检查API速率限制
     */
    public function check_api_rate_limit($result, $server, $request) {
        $route = $request->get_route();
        
        // 只对供应链API进行限制
        if (strpos($route, '/cultural-supply/') === 0) {
            $client_ip = $this->get_client_ip();
            $api_key = $request->get_header('X-API-Key');
            
            $cache_key = 'api_limit_' . md5($client_ip . $api_key);
            $requests = get_transient($cache_key) ?: 0;
            
            // 限制每分钟60次请求
            if ($requests >= 60) {
                return new WP_Error(
                    'too_many_requests',
                    '请求过于频繁，请稍后再试',
                    array('status' => 429)
                );
            }
            
            set_transient($cache_key, $requests + 1, 60);
        }
        
        return $result;
    }
}

8.2 性能优化策略

/**
 * 性能优化模块
 */

class SupplyChainPerformance {
    
    /**
     * 初始化性能优化
     */
    public function init_optimization() {
        // 启用数据缓存
        $this->enable_caching();
        
        // 优化数据库查询
        add_action('init', array($this, 'optimize_queries'));
        
        // 延迟加载非关键资源
        add_action('wp_enqueue_scripts', array($this, 'defer_non_critical_assets'));
        
        // 定期清理旧数据
        if (!wp_next_scheduled('cleanup_old_data')) {
            wp_schedule_event(time(), 'daily', 'cleanup_old_data');
        }
        
        add_action('cleanup_old_data', array($this, 'cleanup_old_records'));
    }
    
    /**
     * 启用缓存
     */
    private function enable_caching() {
        // 缓存供应商数据
        add_filter('pre_get_suppliers', array($this, 'get_cached_suppliers'), 10, 2);
        
        // 缓存库存数据
        add_filter('pre_get_inventory', array($this, 'get_cached_inventory'), 10, 2);
        
        // 设置缓存过期时间
        $this->set_cache_expiration();
    }
    
    /**
     * 获取缓存的供应商数据
     */
    public function get_cached_suppliers($false, $args) {
        $cache_key = 'suppliers_' . md5(serialize($args));
        $cached = wp_cache_get($cache_key, 'cultural_supply');
        
        if ($cached !== false) {
            return $cached;
        }
        
        return false; // 返回false让系统查询数据库
    }
    
    /**
     * 优化数据库查询
     */
    public function optimize_queries() {
        global $wpdb;
        
        // 添加必要的索引
        $this->add_database_indexes();
        
        // 优化查询语句
        add_filter('query', array($this, 'optimize_query_structure'));
    }
    
    /**
     * 添加数据库索引
     */
    private function add_database_indexes() {
        global $wpdb;
        
        $indexes = array(
            "{$wpdb->prefix}cultural_inventory" => array(
                'product_sku',
                'supplier_id',
                'available',
                'last_synced'
            ),
            "{$wpdb->prefix}cultural_order_allocations" => array(
                'order_id',
                'supplier_id',
                'status',
                'created_at'
            )
        );
        
        foreach ($indexes as $table => $columns) {
            foreach ($columns as $column) {
                $this->add_index_if_not_exists($table, $column);
            }
        }
    }
    
    /**
     * 清理旧记录
     */
    public function cleanup_old_records() {
        global $wpdb;
        
        // 清理90天前的日志
        $wpdb->query($wpdb->prepare("