如何开发一套固定资产管理系统？（附架构图+流程图+代码参考）

graph LR
  subgraph Client
    WebApp[Web 前端]
    Mobile[移动扫码/APP]
  end
  subgraph Backend
    API[REST/GraphQL API]
    Auth[鉴权服务（OAuth2/JWT）]
    Worker[异步任务/定时任务（折旧、提醒）]
    Integrator[ERP/财务集成模块]
  end
  subgraph DB
    Postgres[(PostgreSQL)]
    Redis[(Redis 缓存/队列)]
  end
  Client -->|HTTPS| API
  Mobile -->|HTTPS| API
  API --> Auth
  API --> Postgres
  API --> Redis
  Worker --> Postgres
  Worker --> Redis
  API --> Integrator

flowchart TD
  A[申购] --> B[审批]
  B --> C[采购入库]
  C --> D[验收并入固定资产台账]
  D --> E[使用（领用/调拨）]
  E --> F[报修/维修]
  F --> E
  E --> G[盘点]
  G --> H{是否一致?}
  H -- 是 --> E
  H -- 否 --> I[调整台账 / 报差异]
  E --> J[处置（报废/出售）]
  J --> K[财务处理/更新台账]

-- 资产主表
CREATE TABLE asset (
  id BIGSERIAL PRIMARY KEY,
  asset_code VARCHAR(64) NOT NULL UNIQUE,
  name VARCHAR(200) NOT NULL,
  category_id INT NOT NULL,
  model VARCHAR(100),
  serial_no VARCHAR(100),
  purchase_date DATE,
  purchase_price NUMERIC(14,2),
  current_value NUMERIC(14,2),
  accumulated_depreciation NUMERIC(14,2) DEFAULT 0,
  location_id INT,
  custodian_user_id BIGINT,
  status VARCHAR(32) DEFAULT 'IN_USE', -- IN_USE, MAINTENANCE, SCRAPPED, DISPOSED
  version INT DEFAULT 0, -- 乐观锁
  created_at TIMESTAMP DEFAULT now(),
  updated_at TIMESTAMP DEFAULT now()
);
-- 资产历史（变更、维修、处置记录）
CREATE TABLE asset_history (
  id BIGSERIAL PRIMARY KEY,
  asset_id BIGINT NOT NULL REFERENCES asset(id),
  type VARCHAR(50) NOT NULL, -- PURCHASE, MAINTENANCE, TRANSFER, DISPOSAL, INVENTORY
  note TEXT,
  cost NUMERIC(14,2),
  operator_id BIGINT,
  created_at TIMESTAMP DEFAULT now()
);
-- 盘点表
CREATE TABLE inventory_count (
  id BIGSERIAL PRIMARY KEY,
  name VARCHAR(200) NOT NULL,
  start_at TIMESTAMP,
  end_at TIMESTAMP,
  status VARCHAR(20) DEFAULT 'PLANNED' -- PLANNED, IN_PROGRESS, COMPLETED
);
CREATE TABLE inventory_count_detail (
  id BIGSERIAL PRIMARY KEY,
  inventory_count_id BIGINT REFERENCES inventory_count(id),
  asset_id BIGINT REFERENCES asset(id),
  scanned BOOLEAN DEFAULT false,
  scanned_by BIGINT,
  scanned_at TIMESTAMP,
  expected_location_id INT,
  scanned_location_id INT,
  note TEXT
);

// models/asset.js
module.exports = (sequelize, DataTypes) => {
  const Asset = sequelize.define('Asset', {
    id: { type: DataTypes.BIGINT, primaryKey: true, autoIncrement: true },
    asset_code: { type: DataTypes.STRING, unique: true },
    name: DataTypes.STRING,
    category_id: DataTypes.INTEGER,
    model: DataTypes.STRING,
    serial_no: DataTypes.STRING,
    purchase_date: DataTypes.DATEONLY,
    purchase_price: DataTypes.DECIMAL(14,2),
    current_value: DataTypes.DECIMAL(14,2),
    accumulated_depreciation: { type: DataTypes.DECIMAL(14,2), defaultValue: 0 },
    location_id: DataTypes.INTEGER,
    custodian_user_id: DataTypes.BIGINT,
    status: { type: DataTypes.STRING, defaultValue: 'IN_USE' },
    version: { type: DataTypes.INTEGER, defaultValue: 0 }
  }, {
    tableName: 'asset',
    timestamps: true,
    updatedAt: 'updated_at',
    createdAt: 'created_at',
    version: true // Sequelize 会使用 version 字段做乐观锁
  });
  Asset.associate = (models) => {
    Asset.hasMany(models.AssetHistory, { foreignKey: 'asset_id' });
  };
  return Asset;
};

// routes/asset.js
const express = require('express');
const router = express.Router();
router.post('/inbound', async (req, res) => {
  const { purchaseOrderId, items, operatorId } = req.body;
  const t = await sequelize.transaction();
  try {
    // 幂等：检查 purchaseOrderId 是否已处理
    const existing = await AssetHistory.findOne({ where: { note: `PO:${purchaseOrderId}`, type: 'PURCHASE' }, transaction: t });
    if (existing) {
      await t.rollback();
      return res.status(409).json({ message: '采购单已入库' });
    }
    const createdAssets = [];
    for (const it of items) {
      const code = generateAssetCode(it.category_id);
      const asset = await Asset.create({
        asset_code: code,
        name: it.name,
        category_id: it.category_id,
        model: it.model,
        serial_no: it.serial_no,
        purchase_date: it.purchase_date,
        purchase_price: it.price,
        current_value: it.price,
        location_id: it.location_id,
        custodian_user_id: it.custodian_user_id
      }, { transaction: t });
      await AssetHistory.create({
        asset_id: asset.id,
        type: 'PURCHASE',
        note: `PO:${purchaseOrderId}`,
        cost: it.price,
        operator_id: operatorId
      }, { transaction: t });
      createdAssets.push(asset);
    }
    await t.commit();
    res.json({ created: createdAssets.length, assets: createdAssets });
  } catch (err) {
    await t.rollback();
    console.error(err);
    res.status(500).json({ message: '入库失败', error: err.message });
  }
});

async function processInventoryResult(inventoryId, detailList, operatorId) {
  const t = await sequelize.transaction();
  try {
    for (const d of detailList) {
      const asset = await Asset.findByPk(d.asset_id, { transaction: t, lock: t.LOCK.UPDATE });
      if (!asset) {
        // 新发现的实物（账外资产）
        const newAsset = await Asset.create({
          asset_code: generateAssetCode(d.category_id || 0),
          name: d.name || '未知',
          category_id: d.category_id || null,
          current_value: d.estimated_value || 0,
          status: 'IN_USE'
        }, { transaction: t });
        await AssetHistory.create({ asset_id: newAsset.id, type: 'INVENTORY_FOUND', note: `Found in inventory ${inventoryId}`, operator_id: operatorId }, { transaction: t });
      } else {
        // 若位置或状态不一致，记录并更新
        if (asset.location_id !== d.scanned_location_id) {
          await AssetHistory.create({ asset_id: asset.id, type: 'INVENTORY_ADJUST', note: `Location mismatch. Expected ${asset.location_id}, found ${d.scanned_location_id}`, operator_id: operatorId }, { transaction: t });
          asset.location_id = d.scanned_location_id;
          await asset.save({ transaction: t });
        }
        // 标记扫描
        await InventoryCountDetail.update({ scanned: true, scanned_by: operatorId, scanned_at: new Date() }, { where: { id: d.detail_id }, transaction: t });
      }
    }
    await InventoryCount.update({ status: 'COMPLETED', end_at: new Date() }, { where: { id: inventoryId }, transaction: t });
    await t.commit();
  } catch (err) {
    await t.rollback();
    throw err;
  }
}

// 审批通过后调用
await sequelize.transaction(async (t) => {
  await AssetHistory.create({ asset_id, type: 'DISPOSAL', note: disposalNote, cost: disposalPrice, operator_id }, { transaction: t });
  await Asset.update({ status: 'DISPOSED', current_value: 0 }, { where: { id: asset_id }, transaction: t });
  // 推送会计凭证到财务系统（异步）
  queuePush('finance.disposal', { asset_id, disposalPrice, operator_id });
});