进销存系统智能采购计划与供应链协同

发布时间：2025-06-18 | 分类：采购管理

引言

采购是进销存系统中至关重要的环节，直接影响企业的库存成本、资金占用和供货及时性。智能采购计划可以根据销售预测、库存状况、供应商能力等多维度数据，自动生成最优采购方案，实现供应链的协同优化。

智能采购计划框架

构建智能采购计划系统需要综合考虑多个因素：

智能采购算法实现

// 智能采购计划引擎
class SmartPurchasePlanner {
  constructor(inventoryModel, supplierModel, demandModel) {
    this.Inventory = inventoryModel;
    this.Supplier = supplierModel;
    this.Demand = demandModel;
  }

  // 生成采购计划
  async generatePurchasePlan(horizonDays = 30) {
    const plan = {
      items: [],
      totalAmount: 0,
      generatedAt: new Date()
    };

    // 1. 获取所有产品需求预测
    const demandForecast = await this.Demand.forecast(horizonDays);

    // 2. 获取当前库存
    const currentInventory = await this.Inventory.getAll();

    // 3. 计算每个产品的采购需求
    for (const product of demandForecast.products) {
      const purchase = await this.calculatePurchaseQuantity(
        product,
        demandForecast.demand[product.id],
        currentInventory[product.id]
      );

      if (purchase.suggestedQty > 0) {
        // 4. 选择最优供应商
        const supplier = await this.selectBestSupplier(product, purchase.suggestedQty);

        plan.items.push({
          productId: product.id,
          productName: product.name,
          currentStock: purchase.currentStock,
          forecastDemand: purchase.forecastDemand,
          suggestedQty: purchase.suggestedQty,
          supplier: supplier,
          expectedCost: purchase.suggestedQty * supplier.unitPrice,
          orderDate: this.calculateOrderDate(purchase.leadTime),
          expectedDelivery: this.calculateDeliveryDate(purchase.leadTime)
        });

        plan.totalAmount += purchase.suggestedQty * supplier.unitPrice;
      }
    }

    return plan;
  }

  // 计算采购数量
  async calculatePurchaseQuantity(product, forecastDemand, currentInventory) {
    const currentStock = currentInventory?.quantity || 0;
    const safetyStock = product.safetyStock || 100;
    const leadTime = product.leadTimeDays || 7;

    // 安全库存天数
    const safetyDays = leadTime + 3;

    // 预测需求
    const totalDemand = forecastDemand.total;

    // 目标库存 = 安全库存 + 预测需求
    const targetStock = safetyStock + totalDemand;

    // 采购数量 = 目标库存 - 当前库存
    let suggestedQty = targetStock - currentStock;

    // 最小起订量约束
    if (suggestedQty < product.minOrderQty) {
      suggestedQty = suggestedQty > 0 ? product.minOrderQty : 0;
    }

    // 经济订货量优化（EOQ）
    if (suggestedQty > 0) {
      const eoq = this.calculateEOQ(
        product.annualDemand || totalDemand * 12,
        product.orderCost || 100,
        product.holdingCostRate || 0.2,
        product.unitPrice
      );
      suggestedQty = Math.max(suggestedQty, eoq);
    }

    return {
      currentStock,
      forecastDemand: totalDemand,
      safetyStock,
      targetStock,
      suggestedQty: Math.max(0, Math.ceil(suggestedQty))
    };
  }

  // 经济订货量计算
  calculateEOQ(annualDemand, orderCost, holdingCostRate, unitPrice) {
    const eoq = Math.sqrt(
      (2 * annualDemand * orderCost) /
      (holdingCostRate * unitPrice)
    );
    return Math.ceil(eoq);
  }

  // 选择最优供应商
  async selectBestSupplier(product, quantity) {
    const suppliers = await this.Supplier.findByProduct(product.id);

    if (suppliers.length === 0) {
      throw new Error(`No supplier found for product ${product.id}`);
    }

    // 评分选择
    const scored = suppliers.map(s => {
      let score = 0;

      // 价格得分（权重40%）
      const priceScore = (s.unitPrice / Math.min(...suppliers.map(x => x.unitPrice))) * 40;
      score += priceScore;

      // 质量得分（权重25%）
      score += s.qualityScore * 0.25;

      // 交期得分（权重20%）
      const deliveryScore = (1 - s.avgLeadTime / 30) * 20;
      score += deliveryScore;

      // 响应得分（权重15%）
      score += s.responseRate * 0.15;

      return { supplier: s, score };
    });

    // 选择得分最高的供应商
    scored.sort((a, b) => b.score - a.score);

    return {
      id: scored[0].supplier.id,
      name: scored[0].supplier.name,
      unitPrice: scored[0].supplier.unitPrice,
      leadTime: scored[0].supplier.avgLeadTime,
      score: scored[0].score
    };
  }

  // 计算订单日期
  calculateOrderDate(leadTime) {
    const orderDate = new Date();
    orderDate.setDate(orderDate.getDate() - leadTime);
    return orderDate;
  }

  // 计算到货日期
  calculateDeliveryDate(leadTime) {
    const deliveryDate = new Date();
    deliveryDate.setDate(deliveryDate.getDate() + leadTime);
    return deliveryDate;
  }
}

供应链协同平台

实现与供应商的数字化协同：

// 供应链协同服务
class SupplyChainCollaboration {
  constructor() {
    this.supplierPortal = new SupplierPortal();
    this.orderSystem = new OrderSystem();
    this.notificationService = new NotificationService();
  }

  // 供应商门户 - 实时库存共享
  async shareInventoryWithSupplier(supplierId, products) {
    const inventoryData = {};

    for (const productId of products) {
      const product = await Product.findById(productId);
      const inventory = await Inventory.findByProduct(productId);

      inventoryData[productId] = {
        productName: product.name,
        sku: product.sku,
        currentStock: inventory.quantity,
        safetyStock: product.safetyStock,
        reorderPoint: product.reorderPoint,
        pendingOrder: await this.getPendingOrderQty(productId, supplierId),
        lastConsumption: await this.getLastConsumption(productId, 7)
      };
    }

    // 通过供应商门户共享数据
    await this.supplierPortal.pushInventoryData(supplierId, inventoryData);
  }

  // 自动采购订单推送
  async pushPurchaseOrder(order) {
    // 生成符合供应商格式的订单
    const supplierOrder = this.transformToSupplierFormat(order);

    // 推送订单
    await this.supplierPortal.pushOrder(supplierOrder);

    // 发送通知
    await this.notificationService.send({
      type: 'purchase_order',
      supplierId: order.supplierId,
      orderNo: order.orderNo,
      items: order.items.length,
      totalAmount: order.totalAmount
    });
  }

  // 供应商发货通知
  async handleSupplierDispatch(supplierId, dispatchNotice) {
    const order = await PurchaseOrder.findByNo(dispatchNotice.orderNo);

    // 更新订单状态
    order.status = 'in_transit';
    order.dispatchDate = dispatchNotice.dispatchDate;
    order.estimatedArrival = dispatchNotice.estimatedArrival;
    order.trackingNumber = dispatchNotice.trackingNumber;
    await order.save();

    // 更新预期到货
    await this.updateExpectedArrival(order);
  }

  // 到货协同
  async handleArrivalNotification(orderId, arrivalData) {
    const order = await PurchaseOrder.findById(orderId);

    // 验证到货数量
    const receivedItems = arrivalData.items;
    const orderItems = order.items;

    const discrepancies = [];
    for (const item of orderItems) {
      const received = receivedItems.find(r => r.productId === item.productId);
      if (!received) {
        discrepancies.push({ productId: item.productId, expected: item.qty, received: 0 });
      } else if (received.qty !== item.qty) {
        discrepancies.push({ productId: item.productId, expected: item.qty, received: received.qty });
      }
    }

    if (discrepancies.length > 0) {
      // 触发差异处理流程
      await this.handleDiscrepancy(order, discrepancies);
    } else {
      // 正常入库
      await this.processNormalArrival(order, arrivalData);
    }
  }

  // 供应商绩效评估
  async evaluateSupplierPerformance(supplierId, period) {
    const orders = await PurchaseOrder.findBySupplierAndPeriod(supplierId, period);

    const metrics = {
      onTimeDeliveryRate: 0,
      qualityPassRate: 0,
      priceCompetitiveness: 0,
      responseTime: 0,
      overallScore: 0
    };

    let totalOrders = orders.length;
    let onTimeDeliveries = 0;
    let qualityPassed = 0;
    let totalResponseTime = 0;

    for (const order of orders) {
      // 准时交付
      if (order.actualDelivery && order.actualDelivery <= order.expectedDelivery) {
        onTimeDeliveries++;
      }

      // 质量通过
      if (order.qualityStatus === 'passed') {
        qualityPassed++;
      }

      // 响应时间
      totalResponseTime += order.responseTime || 0;
    }

    metrics.onTimeDeliveryRate = (onTimeDeliveries / totalOrders * 100).toFixed(2);
    metrics.qualityPassRate = (qualityPassed / totalOrders * 100).toFixed(2);
    metrics.responseTime = (totalResponseTime / totalOrders).toFixed(1);

    // 综合评分
    metrics.overallScore = (
      metrics.onTimeDeliveryRate * 0.3 +
      metrics.qualityPassRate * 0.3 +
      (100 - metrics.responseTime) * 0.2 +
      metrics.priceCompetitiveness * 0.2
    ).toFixed(2);

    return metrics;
  }
}

采购优化指标

总结

智能采购计划与供应链协同的核心价值：

• 需求预测：基于AI的需求预测，提高采购准确性
• 库存优化：EOQ和安全库存优化，降低库存成本
• 供应商协同：数字化协同，提高供应链响应速度
• 绩效评估：多维度供应商绩效评估，持续优化供应商体系
• 自动化：端到端自动化，减少人工干预和错误

通过智能采购计划和供应链协同，企业可以实现采购成本显著降低、供货及时性提高、库存周转加快的目标。