WordPress柔性供应链中的供应商协同平台开发详解

引言：柔性供应链与供应商协同的重要性

在当今快速变化的市场环境中，企业供应链面临着前所未有的挑战。柔性供应链通过提高响应速度、降低库存成本和增强市场适应性，成为企业保持竞争力的关键。供应商协同作为柔性供应链的核心组成部分，能够实现信息共享、流程对接和资源优化，显著提升整体供应链效率。

WordPress作为全球最流行的内容管理系统，其强大的扩展性和丰富的生态系统使其成为构建供应商协同平台的理想选择。本文将详细解析如何基于WordPress开发一个功能完整的供应商协同平台。

平台架构设计

系统架构概览

供应商协同平台采用模块化设计，主要包含以下核心模块：

1. 用户管理模块 - 处理供应商、采购商和管理员的身份验证与权限控制
2. 产品目录模块 - 管理产品信息、规格和分类
3. 订单管理模块 - 处理采购订单、发货通知和收货确认
4. 库存管理模块 - 实时监控库存水平和预警
5. 报表分析模块 - 提供供应链绩效数据可视化
6. 消息通知模块 - 实现平台内外的即时通信

技术栈选择

• 核心框架：WordPress 6.0+
• 开发方式：自定义主题 + 插件开发
• 数据库：MySQL 8.0
• 前端技术：React.js + REST API
• 安全机制：JWT认证 + 角色权限控制

核心功能模块开发

1. 供应商管理模块

供应商管理是协同平台的基础，需要实现供应商注册、审核、分类和绩效评估功能。

<?php
/**
 * 供应商自定义帖子类型注册
 */
function register_supplier_post_type() {
    $labels = array(
        'name'               => '供应商',
        'singular_name'      => '供应商',
        'menu_name'          => '供应商管理',
        'add_new'            => '添加供应商',
        'add_new_item'       => '添加新供应商',
        'edit_item'          => '编辑供应商',
        'new_item'           => '新供应商',
        'view_item'          => '查看供应商',
        'search_items'       => '搜索供应商',
        'not_found'          => '未找到供应商',
        'not_found_in_trash' => '回收站中无供应商'
    );
    
    $args = array(
        'labels'             => $labels,
        'public'             => true,
        'publicly_queryable' => true,
        'show_ui'            => true,
        'show_in_menu'       => true,
        'query_var'          => true,
        'rewrite'            => array('slug' => 'supplier'),
        'capability_type'    => 'post',
        'has_archive'        => true,
        'hierarchical'       => false,
        'menu_position'      => 5,
        'supports'           => array('title', 'editor', 'thumbnail', 'custom-fields'),
        'show_in_rest'       => true, // 启用REST API支持
    );
    
    register_post_type('supplier', $args);
}
add_action('init', 'register_supplier_post_type');

/**
 * 供应商分类法注册
 */
function register_supplier_taxonomy() {
    $args = array(
        'hierarchical'      => true,
        'labels'            => array(
            'name' => '供应商分类',
            'singular_name' => '分类',
        ),
        'show_ui'           => true,
        'show_admin_column' => true,
        'query_var'         => true,
        'rewrite'           => array('slug' => 'supplier-category'),
        'show_in_rest'      => true,
    );
    
    register_taxonomy('supplier_category', array('supplier'), $args);
}
add_action('init', 'register_supplier_taxonomy');
?>

2. 产品目录管理

产品目录需要支持多供应商产品展示、实时库存查询和价格管理。

<?php
/**
 * 产品管理REST API端点扩展
 */
class Product_API_Controller {
    
    // 注册自定义REST路由
    public function register_routes() {
        register_rest_route('supply-chain/v1', '/products/(?P<id>d+)', array(
            array(
                'methods'  => WP_REST_Server::READABLE,
                'callback' => array($this, 'get_product_details'),
                'permission_callback' => array($this, 'check_permissions'),
            ),
            array(
                'methods'  => WP_REST_Server::EDITABLE,
                'callback' => array($this, 'update_product_inventory'),
                'permission_callback' => array($this, 'check_permissions'),
            ),
        ));
        
        register_rest_route('supply-chain/v1', '/suppliers/(?P<supplier_id>d+)/products', array(
            'methods'  => WP_REST_Server::READABLE,
            'callback' => array($this, 'get_supplier_products'),
            'permission_callback' => array($this, 'check_permissions'),
        ));
    }
    
    // 获取产品详情
    public function get_product_details($request) {
        $product_id = $request['id'];
        
        // 获取产品基本信息
        $product = get_post($product_id);
        
        if (!$product) {
            return new WP_Error('product_not_found', '产品不存在', array('status' => 404));
        }
        
        // 获取产品元数据
        $product_meta = get_post_meta($product_id);
        
        // 获取库存信息
        $inventory = $this->get_real_time_inventory($product_id);
        
        // 获取供应商信息
        $supplier_id = get_post_meta($product_id, '_supplier_id', true);
        $supplier_info = $this->get_supplier_info($supplier_id);
        
        $response_data = array(
            'id'           => $product_id,
            'name'         => $product->post_title,
            'description'  => $product->post_content,
            'sku'          => $product_meta['_sku'][0] ?? '',
            'price'        => $product_meta['_price'][0] ?? 0,
            'inventory'    => $inventory,
            'supplier'     => $supplier_info,
            'last_updated' => $product->post_modified,
        );
        
        return rest_ensure_response($response_data);
    }
    
    // 实时库存查询
    private function get_real_time_inventory($product_id) {
        global $wpdb;
        
        $table_name = $wpdb->prefix . 'supply_chain_inventory';
        
        $inventory = $wpdb->get_var($wpdb->prepare(
            "SELECT quantity FROM $table_name WHERE product_id = %d AND status = 'available'",
            $product_id
        ));
        
        return $inventory ? intval($inventory) : 0;
    }
    
    // 权限检查
    public function check_permissions($request) {
        // 检查用户是否登录且有相应权限
        if (!is_user_logged_in()) {
            return new WP_Error('rest_forbidden', '请先登录', array('status' => 401));
        }
        
        $user = wp_get_current_user();
        $allowed_roles = array('administrator', 'supplier', 'purchaser');
        
        if (array_intersect($allowed_roles, $user->roles)) {
            return true;
        }
        
        return new WP_Error('rest_forbidden', '权限不足', array('status' => 403));
    }
}

// 初始化API控制器
add_action('rest_api_init', function() {
    $controller = new Product_API_Controller();
    $controller->register_routes();
});
?>

3. 订单协同处理系统

订单协同是供应商协同平台的核心，需要实现订单创建、状态跟踪和自动通知功能。

/**
 * 订单协同处理前端组件
 * 使用React.js实现
 */
import React, { useState, useEffect } from 'react';
import axios from 'axios';

const OrderCollaboration = ({ orderId }) => {
    const [order, setOrder] = useState(null);
    const [suppliers, setSuppliers] = useState([]);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    // 获取订单详情
    useEffect(() => {
        const fetchOrderDetails = async () => {
            try {
                const token = localStorage.getItem('supply_chain_token');
                const response = await axios.get(
                    `/wp-json/supply-chain/v1/orders/${orderId}`,
                    {
                        headers: { Authorization: `Bearer ${token}` }
                    }
                );
                setOrder(response.data);
            } catch (err) {
                setError('获取订单信息失败');
            } finally {
                setLoading(false);
            }
        };

        fetchOrderDetails();
    }, [orderId]);

    // 分配订单给供应商
    const assignToSupplier = async (supplierId) => {
        try {
            const token = localStorage.getItem('supply_chain_token');
            await axios.post(
                `/wp-json/supply-chain/v1/orders/${orderId}/assign`,
                { supplier_id: supplierId },
                {
                    headers: { 
                        Authorization: `Bearer ${token}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            // 发送通知
            await sendNotification(supplierId, 'new_order_assigned', {
                order_id: orderId,
                message: '您有新的订单需要处理'
            });
            
            alert('订单分配成功，已通知供应商');
        } catch (err) {
            alert('订单分配失败');
        }
    };

    // 发送实时通知
    const sendNotification = async (userId, type, data) => {
        try {
            await axios.post('/wp-json/supply-chain/v1/notifications', {
                user_id: userId,
                type: type,
                data: data,
                timestamp: new Date().toISOString()
            });
        } catch (err) {
            console.error('通知发送失败:', err);
        }
    };

    // 订单状态跟踪
    const OrderStatusTracker = ({ status }) => {
        const statusSteps = [
            { id: 1, name: '待处理', key: 'pending' },
            { id: 2, name: '已确认', key: 'confirmed' },
            { id: 3, name: '生产中', key: 'production' },
            { id: 4, name: '已发货', key: 'shipped' },
            { id: 5, name: '已完成', key: 'completed' }
        ];

        return (
            <div className="order-status-tracker">
                <h3>订单状态跟踪</h3>
                <div className="status-steps">
                    {statusSteps.map((step) => (
                        <div 
                            key={step.id}
                            className={`status-step ${status === step.key ? 'active' : ''}`}
                        >
                            <div className="step-number">{step.id}</div>
                            <div className="step-name">{step.name}</div>
                        </div>
                    ))}
                </div>
            </div>
        );
    };

    if (loading) return <div>加载中...</div>;
    if (error) return <div>{error}</div>;

    return (
        <div className="order-collaboration-container">
            <h2>订单协同管理</h2>
            
            {order && (
                <>
                    <div className="order-info">
                        <h3>订单信息</h3>
                        <p>订单号: {order.order_number}</p>
                        <p>总金额: ¥{order.total_amount}</p>
                        <p>创建时间: {new Date(order.created_at).toLocaleString()}</p>
                    </div>
                    
                    <OrderStatusTracker status={order.status} />
                    
                    <div className="supplier-selection">
                        <h3>选择供应商</h3>
                        <select 
                            onChange={(e) => assignToSupplier(e.target.value)}
                            defaultValue=""
                        >
                            <option value="" disabled>请选择供应商</option>
                            {suppliers.map(supplier => (
                                <option key={supplier.id} value={supplier.id}>
                                    {supplier.name} - 评级: {supplier.rating}
                                </option>
                            ))}
                        </select>
                    </div>
                    
                    <div className="order-items">
                        <h3>订单商品</h3>
                        <table>
                            <thead>
                                <tr>
                                    <th>商品名称</th>
                                    <th>数量</th>
                                    <th>单价</th>
                                    <th>小计</th>
                                </tr>
                            </thead>
                            <tbody>
                                {order.items.map(item => (
                                    <tr key={item.product_id}>
                                        <td>{item.product_name}</td>
                                        <td>{item.quantity}</td>
                                        <td>¥{item.unit_price}</td>
                                        <td>¥{item.subtotal}</td>
                                    </tr>
                                ))}
                            </tbody>
                        </table>
                    </div>
                </>
            )}
        </div>
    );
};

export default OrderCollaboration;

数据库设计优化

核心数据表结构

-- 供应商信息表
CREATE TABLE wp_supply_chain_suppliers (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    company_name VARCHAR(255) NOT NULL,
    contact_person VARCHAR(100),
    email VARCHAR(100) UNIQUE NOT NULL,
    phone VARCHAR(50),
    address TEXT,
    certification_status ENUM('pending', 'approved', 'rejected') DEFAULT 'pending',
    performance_score DECIMAL(3,2) DEFAULT 0.00,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES wp_users(ID) ON DELETE CASCADE
);

-- 产品库存表（支持实时库存查询）
CREATE TABLE wp_supply_chain_inventory (
    id INT AUTO_INCREMENT PRIMARY KEY,
    product_id INT NOT NULL,
    supplier_id INT NOT NULL,
    quantity INT NOT NULL DEFAULT 0,
    reserved_quantity INT DEFAULT 0,
    status ENUM('available', 'reserved', 'out_of_stock') DEFAULT 'available',
    location VARCHAR(100),
    last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    INDEX idx_product_supplier (product_id, supplier_id),
    INDEX idx_status (status)
);

-- 订单协同记录表
CREATE TABLE wp_supply_chain_order_collaboration (
    id INT AUTO_INCREMENT PRIMARY KEY,
    order_id INT NOT NULL,
    supplier_id INT NOT NULL,
    current_status VARCHAR(50) NOT NULL,
    previous_status VARCHAR(50),
    action_performed VARCHAR(100),
    performed_by INT NOT NULL,
    notes TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_order_supplier (order_id, supplier_id),
    INDEX idx_status (current_status)
);

-- 实时消息通知表
CREATE TABLE wp_supply_chain_notifications (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    notification_type VARCHAR(50) NOT NULL,
    title VARCHAR(255) NOT NULL,
    message TEXT NOT NULL,
    data JSON,
    is_read BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_user_unread (user_id, is_read)
);

安全与性能优化

安全措施实现

<?php
/**
 * 供应链平台安全增强模块
 */
class SupplyChainSecurity {
    
    // 防止SQL注入的数据验证
    public static function validate_input($input, $type = 'string') {
        switch ($type) {
            case 'email':
                return sanitize_email($input);
            case 'int':
                return intval($input);
            case 'float':
                return floatval($input);
            case 'text':
                return sanitize_textarea_field($input);
            default:
                return sanitize_text_field($input);
        }
    }
    
    // JWT令牌生成与验证
    public static function generate_jwt_token($user_id) {
        $header = json_encode(['typ' => 'JWT', 'alg' => 'HS256']);
        $payload = json_encode([
            'user_id' => $user_id,
            'iat' => time(),
            'exp' => time() + (24 * 60 * 60) // 24小时过期
        ]);
        
        $base64UrlHeader = str_replace(['+', '/', '='], ['-', '_', ''], base64_encode($header));
        $base64UrlPayload = str_replace(['+', '/', '='], ['-', '_', ''], base64_encode($payload));
        
        $signature = hash_hmac('sha256', 
            $base64UrlHeader . "." . $base64UrlPayload, 
            wp_salt(), 
            true
        );
        
        $base64UrlSignature = str_replace(['+', '/', '='], ['-', '_', ''], base64_encode($signature));
        
        return $base64UrlHeader . "." . $base64UrlPayload . "." . $base64UrlSignature;
    }
    
    // API请求频率限制
    public static function rate_limit_check($user_id, $action, $limit = 100, $period = 3600) {
        $transient_key = 'rate_limit_' . $user_id . '_' . $action;
        $requests = get_transient($transient_key) ?: 0;
        
        if ($requests >= $limit) {
            return false;
        }
        
        set_transient($transient_key, $requests + 1, $period);
        return true;
    }
}

/**
 * 数据缓存优化
 */
class SupplyChainCache {
    
    private static $cache_group = 'supply_chain';
    
    // 设置缓存
    public static function set($key, $data, $expiration = 3600) {
        wp_cache_set($key, $data, self::$cache_group, $expiration);
    }
    
    // 获取缓存
    public static function get($key) {
        return wp_cache_get($key, self::$cache_group);
    }
    
    // 产品信息缓存
    public static function cache_product_info($product_id) {

        $cached_data = self::get($cache_key);
        
        if ($cached_data !== false) {
            return $cached_data;
        }
        
        // 从数据库获取产品信息
        global $wpdb;
        $product_data = $wpdb->get_row($wpdb->prepare(
            "SELECT p.*, 
                    pm1.meta_value as price,
                    pm2.meta_value as sku,
                    pm3.meta_value as supplier_id
             FROM {$wpdb->posts} p
             LEFT JOIN {$wpdb->postmeta} pm1 ON p.ID = pm1.post_id AND pm1.meta_key = '_price'
             LEFT JOIN {$wpdb->postmeta} pm2 ON p.ID = pm2.post_id AND pm2.meta_key = '_sku'
             LEFT JOIN {$wpdb->postmeta} pm3 ON p.ID = pm3.post_id AND pm3.meta_key = '_supplier_id'
             WHERE p.ID = %d AND p.post_type = 'product' AND p.post_status = 'publish'",
            $product_id
        ));
        
        if ($product_data) {
            // 缓存30分钟
            self::set($cache_key, $product_data, 1800);
        }
        
        return $product_data;
    }
}
?>

实时通信与通知系统

WebSocket实时数据推送

/**
 * WebSocket实时通信服务
 * 用于订单状态更新、库存变化等实时通知
 */
class SupplyChainWebSocket {
    constructor() {
        this.socket = null;
        this.reconnectAttempts = 0;
        this.maxReconnectAttempts = 5;
        this.reconnectDelay = 3000;
        this.messageHandlers = new Map();
        this.userId = this.getCurrentUserId();
    }

    // 初始化WebSocket连接
    connect() {
        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
        const wsUrl = `${protocol}//${window.location.host}/ws/supply-chain`;
        
        this.socket = new WebSocket(wsUrl);
        
        this.socket.onopen = () => {
            console.log('供应链WebSocket连接已建立');
            this.reconnectAttempts = 0;
            
            // 发送身份验证
            this.send({
                type: 'auth',
                userId: this.userId,
                token: this.getAuthToken()
            });
        };
        
        this.socket.onmessage = (event) => {
            this.handleMessage(JSON.parse(event.data));
        };
        
        this.socket.onclose = () => {
            console.log('WebSocket连接关闭，尝试重连...');
            this.handleReconnect();
        };
        
        this.socket.onerror = (error) => {
            console.error('WebSocket错误:', error);
        };
    }
    
    // 消息处理
    handleMessage(data) {
        const { type, payload } = data;
        
        switch (type) {
            case 'order_update':
                this.handleOrderUpdate(payload);
                break;
            case 'inventory_alert':
                this.handleInventoryAlert(payload);
                break;
            case 'supplier_message':
                this.handleSupplierMessage(payload);
                break;
            case 'system_notification':
                this.handleSystemNotification(payload);
                break;
            default:
                console.log('未知消息类型:', type);
        }
        
        // 触发注册的消息处理器
        if (this.messageHandlers.has(type)) {
            this.messageHandlers.get(type).forEach(handler => handler(payload));
        }
    }
    
    // 订单状态更新处理
    handleOrderUpdate(orderData) {
        const { orderId, newStatus, updatedBy, timestamp } = orderData;
        
        // 更新本地订单状态
        this.updateLocalOrderStatus(orderId, newStatus);
        
        // 显示通知
        this.showNotification({
            title: '订单状态更新',
            message: `订单 ${orderId} 状态已变更为: ${this.getStatusText(newStatus)}`,
            type: 'info',
            timestamp: timestamp
        });
    }
    
    // 库存预警处理
    handleInventoryAlert(inventoryData) {
        const { productId, productName, currentStock, minStock } = inventoryData;
        
        if (currentStock <= minStock) {
            this.showNotification({
                title: '库存预警',
                message: `产品 ${productName} 库存不足，当前库存: ${currentStock}`,
                type: 'warning',
                action: {
                    label: '立即补货',
                    callback: () => this.initiateReplenishment(productId)
                }
            });
        }
    }
    
    // 发送消息
    send(data) {
        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
            this.socket.send(JSON.stringify(data));
        } else {
            console.warn('WebSocket未连接，消息发送失败:', data);
        }
    }
    
    // 注册消息处理器
    on(messageType, handler) {
        if (!this.messageHandlers.has(messageType)) {
            this.messageHandlers.set(messageType, []);
        }
        this.messageHandlers.get(messageType).push(handler);
    }
    
    // 断线重连处理
    handleReconnect() {
        if (this.reconnectAttempts < this.maxReconnectAttempts) {
            this.reconnectAttempts++;
            setTimeout(() => {
                console.log(`第 ${this.reconnectAttempts} 次重连尝试...`);
                this.connect();
            }, this.reconnectDelay * this.reconnectAttempts);
        }
    }
    
    // 获取当前用户ID
    getCurrentUserId() {
        const userData = localStorage.getItem('supply_chain_user');
        return userData ? JSON.parse(userData).id : null;
    }
    
    // 获取认证令牌
    getAuthToken() {
        return localStorage.getItem('supply_chain_token');
    }
}

// 初始化WebSocket服务
const supplyChainWS = new SupplyChainWebSocket();

// 页面加载时连接
document.addEventListener('DOMContentLoaded', () => {
    if (window.location.pathname.includes('/supply-chain/')) {
        supplyChainWS.connect();
    }
});

移动端适配与PWA支持

响应式设计与PWA配置

/**
 * 供应链平台PWA服务工作者
 * 提供离线访问和推送通知功能
 */
const CACHE_NAME = 'supply-chain-v1';
const OFFLINE_URL = '/offline.html';

// 需要缓存的资源
const CACHE_ASSETS = [
    '/',
    '/wp-content/themes/supply-chain/style.css',
    '/wp-content/themes/supply-chain/main.js',
    '/wp-content/plugins/supply-chain-platform/assets/',
    '/wp-json/supply-chain/v1/products',
    OFFLINE_URL
];

// 安装服务工作者
self.addEventListener('install', (event) => {
    event.waitUntil(
        caches.open(CACHE_NAME)
            .then((cache) => {
                console.log('缓存供应链平台资源');
                return cache.addAll(CACHE_ASSETS);
            })
            .then(() => self.skipWaiting())
    );
});

// 激活服务工作者
self.addEventListener('activate', (event) => {
    event.waitUntil(
        caches.keys().then((cacheNames) => {
            return Promise.all(
                cacheNames.map((cacheName) => {
                    if (cacheName !== CACHE_NAME) {
                        console.log('删除旧缓存:', cacheName);
                        return caches.delete(cacheName);
                    }
                })
            );
        }).then(() => self.clients.claim())
    );
});

// 拦截网络请求
self.addEventListener('fetch', (event) => {
    // 跳过非GET请求和Chrome扩展
    if (event.request.method !== 'GET' || 
        event.request.url.startsWith('chrome-extension://')) {
        return;
    }
    
    event.respondWith(
        caches.match(event.request)
            .then((response) => {
                // 返回缓存或网络请求
                return response || fetch(event.request)
                    .then((networkResponse) => {
                        // 缓存API响应（除了实时数据）
                        if (event.request.url.includes('/wp-json/') && 
                            !event.request.url.includes('/realtime/')) {
                            const responseClone = networkResponse.clone();
                            caches.open(CACHE_NAME)
                                .then((cache) => {
                                    cache.put(event.request, responseClone);
                                });
                        }
                        return networkResponse;
                    })
                    .catch(() => {
                        // 网络请求失败，返回离线页面
                        if (event.request.destination === 'document') {
                            return caches.match(OFFLINE_URL);
                        }
                    });
            })
    );
});

// 推送通知处理
self.addEventListener('push', (event) => {
    if (!event.data) return;
    
    const data = event.data.json();
    const options = {
        body: data.body,
        icon: '/wp-content/themes/supply-chain/assets/icon-192x192.png',
        badge: '/wp-content/themes/supply-chain/assets/badge-72x72.png',
        vibrate: [200, 100, 200],
        data: {
            url: data.url || '/'
        },
        actions: [
            {
                action: 'view',
                title: '查看详情'
            },
            {
                action: 'close',
                title: '关闭'
            }
        ]
    };
    
    event.waitUntil(
        self.registration.showNotification(data.title, options)
    );
});

// 通知点击处理
self.addEventListener('notificationclick', (event) => {
    event.notification.close();
    
    if (event.action === 'close') {
        return;
    }
    
    event.waitUntil(
        clients.matchAll({ type: 'window' })
            .then((clientList) => {
                // 如果已有打开的窗口，聚焦它
                for (const client of clientList) {
                    if (client.url === event.notification.data.url && 'focus' in client) {
                        return client.focus();
                    }
                }
                // 否则打开新窗口
                if (clients.openWindow) {
                    return clients.openWindow(event.notification.data.url);
                }
            })
    );
});

性能监控与数据分析

供应链绩效监控仪表板

<?php
/**
 * 供应链绩效分析模块
 */
class SupplyChainAnalytics {
    
    private $db;
    
    public function __construct() {
        global $wpdb;
        $this->db = $wpdb;
    }
    
    /**
     * 计算供应商准时交货率
     */
    public function calculate_on_time_delivery_rate($supplier_id, $start_date, $end_date) {
        $table_orders = $this->db->prefix . 'supply_chain_orders';
        $table_deliveries = $this->db->prefix . 'supply_chain_deliveries';
        
        $query = $this->db->prepare(
            "SELECT 
                COUNT(*) as total_orders,
                SUM(CASE WHEN d.actual_delivery_date <= o.expected_delivery_date THEN 1 ELSE 0 END) as on_time_orders
             FROM {$table_orders} o
             LEFT JOIN {$table_deliveries} d ON o.id = d.order_id
             WHERE o.supplier_id = %d
             AND o.order_date BETWEEN %s AND %s
             AND o.status IN ('completed', 'delivered')",
            $supplier_id,
            $start_date,
            $end_date
        );
        
        $result = $this->db->get_row($query);
        
        if ($result && $result->total_orders > 0) {
            return round(($result->on_time_orders / $result->total_orders) * 100, 2);
        }
        
        return 0;
    }
    
    /**
     * 获取库存周转率分析
     */
    public function get_inventory_turnover_analysis($product_ids = [], $period = 'monthly') {
        $table_inventory = $this->db->prefix . 'supply_chain_inventory_log';
        $table_sales = $this->db->prefix . 'supply_chain_sales';
        
        $where_clause = '';
        if (!empty($product_ids)) {
            $product_ids_str = implode(',', array_map('intval', $product_ids));
            $where_clause = "WHERE i.product_id IN ({$product_ids_str})";
        }
        
        switch ($period) {
            case 'weekly':
                $date_format = "%Y-%u";
                break;
            case 'monthly':
                $date_format = "%Y-%m";
                break;
            case 'quarterly':
                $date_format = "%Y-%m";
                break;
            default:
                $date_format = "%Y-%m";
        }
        
        $query = "
            SELECT 
                DATE_FORMAT(i.log_date, '{$date_format}') as period,
                i.product_id,
                p.post_title as product_name,
                AVG(i.average_inventory) as avg_inventory,
                SUM(s.quantity_sold) as total_sold,
                CASE 
                    WHEN AVG(i.average_inventory) > 0 
                    THEN SUM(s.quantity_sold) / AVG(i.average_inventory)
                    ELSE 0 
                END as turnover_rate
            FROM {$table_inventory} i
            LEFT JOIN {$table_sales} s ON i.product_id = s.product_id 
                AND DATE_FORMAT(i.log_date, '{$date_format}') = DATE_FORMAT(s.sale_date, '{$date_format}')
            LEFT JOIN {$this->db->posts} p ON i.product_id = p.ID
            {$where_clause}
            GROUP BY period, i.product_id
            ORDER BY period DESC, turnover_rate DESC
            LIMIT 100";
        
        return $this->db->get_results($query);
    }
    
    /**
     * 生成供应链KPI报告
     */
    public function generate_kpi_report($start_date, $end_date) {
        $report = [
            'period' => [
                'start' => $start_date,
                'end' => $end_date
            ],
            'supplier_performance' => $this->get_supplier_performance_summary($start_date, $end_date),
            'inventory_metrics' => $this->get_inventory_metrics($start_date, $end_date),
            'order_metrics' => $this->get_order_metrics($start_date, $end_date),
            'cost_analysis' => $this->get_cost_analysis($start_date, $end_date)
        ];
        
        // 计算综合得分
        $report['overall_score'] = $this->calculate_overall_score($report);
        
        return $report;
    }
    
    /**
     * 获取供应商绩效摘要
     */
    private function get_supplier_performance_summary($start_date, $end_date) {
        $table_suppliers = $this->db->prefix . 'supply_chain_suppliers';
        $table_orders = $this->db->prefix . 'supply_chain_orders';
        
        $query = $this->db->prepare(
            "SELECT 
                s.id,
                s.company_name,
                COUNT(o.id) as total_orders,
                AVG(o.quality_rating) as avg_quality,
                AVG(TIMESTAMPDIFF(HOUR, o.order_date, o.delivery_date)) as avg_delivery_hours,
                SUM(CASE WHEN o.status = 'completed' THEN 1 ELSE 0 END) / COUNT(o.id) * 100 as completion_rate
             FROM {$table_suppliers} s
             LEFT JOIN {$table_orders} o ON s.id = o.supplier_id
                AND o.order_date BETWEEN %s AND %s
             GROUP BY s.id
             HAVING total_orders > 0
             ORDER BY avg_quality DESC
             LIMIT 10",
            $start_date,
            $end_date
        );
        
        return $this->db->get_results($query);
    }
    
    /**
     * 计算综合绩效得分
     */
    private function calculate_overall_score($report_data) {
        $weights = [
            'on_time_delivery' => 0.3,
            'quality_score' => 0.25,
            'inventory_turnover' => 0.2,
            'cost_efficiency' => 0.15,
            'order_accuracy' => 0.1
        ];
        
        $scores = [];
        
        // 计算各项得分（这里简化处理，实际需要具体计算逻辑）
        $scores['on_time_delivery'] = $this->calculate_metric_score(
            $report_data['supplier_performance'],
            'completion_rate',
            100
        );
        
        $scores['quality_score'] = $this->calculate_metric_score(
            $report_data['supplier_performance'],
            'avg_quality',
            5
        );
        
        $scores['inventory_turnover'] = $this->calculate_metric_score(
            $report_data['inventory_metrics'],
            'turnover_rate',
            10
        );
        
        // 计算加权总分
        $total_score = 0;
        foreach ($weights as $metric => $weight) {
            if (isset($scores[$metric])) {
                $total_score += $scores[$metric] * $weight;
            }
        }
        
        return round($total_score, 2);
    }
    
    /**
     * 计算指标得分（0-100分）
     */
    private function calculate_metric_score($data, $metric_key, $max_value) {
        if (empty($data)) return 0;
        
        $total = 0;
        $count = 0;
        
        foreach ($data as $item) {
            if (isset($item->$metric_key)) {
                $value = floatval($item->$metric_key);
                $normalized = min($value / $max_value, 1) * 100;
                $total += $normalized;
                $count++;
            }
        }
        
        return $count > 0 ? round($total / $count, 2) : 0;
    }
}

// 注册REST API端点用于获取分析数据
add_action('rest_api_init', function() {
    register_rest_route('supply-chain/v1', '/analytics/kpi-report', [
        'methods' => 'GET',
        'callback' => function($request) {
            $analytics = new SupplyChainAnalytics();
            
            $start_date = $request->get_param('start_date') ?: date('Y-m-01');