如何开发一套ERP（离散制造-MTO）系统（附架构图+流程图+代码参考）

graph LR
  subgraph Users
    A[销售/客服] -->|web| Frontend
    B[计划/车间] -->|web/移动| Frontend
    C[采购/仓库] -->|web| Frontend
    D[财务/管理] -->|web| Frontend
  end
  Frontend --> API_GW[API 网关]
  API_GW --> Auth[认证服务]
  API_GW --> MSales[销售服务]
  API_GW --> MCustomer[客户服务]
  API_GW --> MProd[生产服务]
  API_GW --> MPur[采购服务]
  API_GW --> MInv[库存服务]
  API_GW --> MFin[财务服务]
  API_GW --> MTech[技术管理/PLM接口]
  MProd -->|events| MQ[消息队列(RabbitMQ/Kafka)]
  MPur -->|events| MQ
  MInv -->|events| MQ
  subgraph Persistence
    DBMain[(Postgres)]
    Cache[(Redis)]
    FileStore[(对象存储)]
  end
  MSales --> DBMain
  MProd --> DBMain
  MInv --> DBMain
  MFin --> DBMain
  Auth --> DBMain
  MQ --> DBMain
  MTech --> FileStore
  subgraph Integration
    PLM[PLM/CAD]
    MES[MES/车间系统]
    ERP3P[第三方ERP/供应商门户]
  end
  MTech --> PLM
  MProd --> MES
  MPur --> ERP3P

flowchart TB
  A[客户下单] --> B[销售录入/配置]
  B --> C{是否标准BOM?}
  C -->|是| D[生成生产订单]
  C -->|否| E[派工工程/生成新BOM版本]
  D --> F[MRP：计算物料需求]
  E --> F
  F --> G{物料可用？}
  G -->|是| H[排产并下发派工]
  G -->|否| I[触发采购/外协]
  I --> J[供应到货后入库]
  J --> H
  H --> K[车间执行（MES）]
  K --> L[完工入库]
  L --> M[质检出库/发运]
  M --> N[账务结算/成本核算]

flowchart LR
  A[主产品] --> B[零件A x2]
  A --> C[零件B x1]
  B --> D[原料A1 x3]
  C --> E[原料B1 x2]

// package.json (仅依赖展示)
// {
//   "name": "mto-erp-sample",
//   "dependencies": {
//     "express": "^4.18.2",
//     "typeorm": "^0.3.12",
//     "pg": "^8.10.0",
//     "amqplib": "^0.8.0",
//     "reflect-metadata": "^0.1.13"
//   }
// }
/* src/entity/Material.ts */
import { Entity, PrimaryGeneratedColumn, Column } from "typeorm";
@Entity()
export class Material {
  @PrimaryGeneratedColumn()
  id: number;
  @Column({ unique: true })
  code: string;
  @Column()
  name: string;
  @Column({ default: 0 })
  leadTimeDays: number; // 采购交期
  @Column({ default: 0 })
  safetyStock: number;
}
/* src/entity/BOM.ts */
import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from "typeorm";
@Entity()
export class BOM {
  @PrimaryGeneratedColumn()
  id: number;
  @Column()
  productCode: string; // 成品/半成品代码
  @Column()
  componentCode: string;
  @Column("float")
  qty: number; // 每个成品需要的数量
  @Column({ nullable: true })
  effectiveFrom?: Date;
  @Column({ nullable: true })
  version?: string;
}
/* src/entity/SalesOrder.ts */
import { Entity, PrimaryGeneratedColumn, Column } from "typeorm";
@Entity()
export class SalesOrder {
  @PrimaryGeneratedColumn()
  id: number;
  @Column({ unique: true })
  orderNo: string;
  @Column()
  productCode: string;
  @Column("int")
  qty: number;
  @Column()
  dueDate: Date;
  @Column({ default: 'CREATED' })
  status: string;
}
/* src/app.ts */
import express from "express";
import "reflect-metadata";
import { DataSource } from "typeorm";
import { Material } from "./entity/Material";
import { BOM } from "./entity/BOM";
import { SalesOrder } from "./entity/SalesOrder";
import amqp from "amqplib";
const app = express();
app.use(express.json());
const AppDataSource = new DataSource({
  type: "postgres",
  host: process.env.DB_HOST || "localhost",
  port: 5432,
  username: "postgres",
  password: "postgres",
  database: "mto_erp",
  entities: [Material, BOM, SalesOrder],
  synchronize: true,
});
let channel: amqp.Channel | null = null;
async function initMQ(){
  const conn = await amqp.connect(process.env.RABBIT_URL || "amqp://localhost");
  channel = await conn.createChannel();
  await channel.assertQueue("order.events", { durable: true });
}
AppDataSource.initialize().then(() => {
  console.log("DB connected");
  initMQ().then(()=>console.log("MQ connected"));
});
/* Helper: 展开 BOM（多级） */
async function explodeBOM(productCode: string, qty: number, ds: DataSource) {
  const bomRepo = ds.getRepository(BOM);
  const materialNeeds: Record<string, number> = {};
  // DFS 展开
  async function dfs(code: string, multiplier: number) {
    const nodes = await bomRepo.find({ where: { productCode: code } });
    if (!nodes || nodes.length === 0) {
      // code 是原料或外购件
      materialNeeds[code] = (materialNeeds[code] || 0) + multiplier;
      return;
    }
    for (const n of nodes) {
      await dfs(n.componentCode, multiplier * n.qty);
    }
  }
  await dfs(productCode, qty);
  return materialNeeds; // { materialCode: totalQty }
}
/* 简单 MRP：根据库存/安全库存判断是否需要采购（示例短版） */
async function simpleMRP(productCode: string, qty: number, ds: DataSource) {
  const needs = await explodeBOM(productCode, qty, ds);
  const materialRepo = ds.getRepository(Material);
  const results: Array<{ code: string; need: number; onHand: number; toPurchase: number }> = [];
  for (const code of Object.keys(needs)) {
    const m = await materialRepo.findOneBy({ code });
    const onHand = m ? 0 : 0; // 假设从库存服务获取，示例里用 0
    const safety = m ? m.safetyStock : 0;
    const need = needs[code];
    const toPurchase = Math.max(0, need + safety - onHand);
    results.push({ code, need, onHand, toPurchase });
  }
  return results;
}
/* 创建订单 API：保存订单 -> 触发简单 MRP -> 发布事件给采购/生产 */
app.post("/orders", async (req, res) => {
  const ds = AppDataSource;
  const repo = ds.getRepository(SalesOrder);
  const { orderNo, productCode, qty, dueDate } = req.body;
  try {
    const so = repo.create({ orderNo, productCode, qty, dueDate, status: 'CONFIRMED' });
    await repo.save(so);
    // 1) 计算物料需求
    const mrp = await simpleMRP(productCode, qty, ds);
    // 2) 发布事件
    const payload = { type: 'OrderConfirmed', data: { orderNo, productCode, qty, mrp } };
    if (channel) {
      channel.sendToQueue("order.events", Buffer.from(JSON.stringify(payload)), { persistent: true });
    }
    return res.json({ ok: true, order: so, mrp });
  } catch (err) {
    console.error(err);
    return res.status(500).json({ ok: false, message: 'error' });
  }
});
app.listen(3000, () => {
  console.log("Server started on 3000");
});