如何物业管理（园区式）系统的房屋及设备设施板块？（附架构图+流程图+代码参考）

mermaid
flowchart LR
  A[用户/租户/巡检员] -->|Web/Mobile| B[前端]
  B -->|REST| C[API Gateway]
  C --> D[设备服务]
  C --> E[工单服务]
  C --> F[巡检/保养服务]
  D --> PG[(Postgres)]
  E --> PG
  F --> PG
  D -->|metrics| TSDB[(InfluxDB)]
  C --> MQ[(消息队列)]
  MQ --> G[通知（短信/微信/Push）]
  subgraph IoT
    IOT[传感器/网关] -->|MQTT| C
  end

ts
/* =========================
   简化示例：Postgres 建表 + Node.js (TypeScript) + Express + TypeORM + node-cron
   一块代码包含：
   - 建表 SQL（Postgres）
   - TypeORM 实体
   - 简单 Express 路由（设备、报修、巡检、保养）
   - 调度示例（node-cron）
   - 简单前端 fetch 示例
   ========================= */
/* ---------- Postgres 建表（复制到 psql 执行） ---------- */
-- device, location, repair_ticket, inspection_plan, inspection_record, maintenance_record, spare_part
CREATE TABLE IF NOT EXISTS location (
  id BIGSERIAL PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  parent_id BIGINT,
  type VARCHAR(50),
  address TEXT
);
CREATE TABLE IF NOT EXISTS device (
  id BIGSERIAL PRIMARY KEY,
  code VARCHAR(64) UNIQUE NOT NULL,
  name VARCHAR(255) NOT NULL,
  category VARCHAR(100),
  location_id BIGINT,
  manufacturer VARCHAR(255),
  model VARCHAR(255),
  serial_no VARCHAR(255),
  purchase_date DATE,
  warranty_until DATE,
  status VARCHAR(50) DEFAULT 'in_service',
  metadata JSONB,
  created_at TIMESTAMP DEFAULT now(),
  updated_at TIMESTAMP DEFAULT now()
);
CREATE TABLE IF NOT EXISTS repair_ticket (
  id BIGSERIAL PRIMARY KEY,
  ticket_no VARCHAR(64) UNIQUE NOT NULL,
  device_id BIGINT REFERENCES device(id),
  reporter_id BIGINT,
  priority SMALLINT DEFAULT 3,
  status VARCHAR(50) DEFAULT 'reported',
  description TEXT,
  assigned_to BIGINT,
  attachments JSONB,
  created_at TIMESTAMP DEFAULT now(),
  updated_at TIMESTAMP DEFAULT now()
);
CREATE TABLE IF NOT EXISTS inspection_plan (
  id BIGSERIAL PRIMARY KEY,
  name VARCHAR(255),
  device_category VARCHAR(100),
  frequency VARCHAR(50),
  cron_expr VARCHAR(255),
  checklist JSONB,
  active BOOLEAN DEFAULT true
);
CREATE TABLE IF NOT EXISTS inspection_record (
  id BIGSERIAL PRIMARY KEY,
  plan_id BIGINT REFERENCES inspection_plan(id),
  device_id BIGINT REFERENCES device(id),
  inspector_id BIGINT,
  result JSONB,
  status VARCHAR(50),
  local_id VARCHAR(128), -- 离线同步幂等
  created_at TIMESTAMP DEFAULT now()
);
CREATE TABLE IF NOT EXISTS maintenance_record (
  id BIGSERIAL PRIMARY KEY,
  device_id BIGINT REFERENCES device(id),
  maintenance_type VARCHAR(50),
  performed_by BIGINT,
  notes TEXT,
  parts_used JSONB,
  next_due DATE,
  created_at TIMESTAMP DEFAULT now()
);
CREATE TABLE IF NOT EXISTS spare_part (
  id BIGSERIAL PRIMARY KEY,
  code VARCHAR(64) UNIQUE,
  name VARCHAR(255),
  qty INT DEFAULT 0,
  location VARCHAR(255)
);
/* ---------- TypeORM 实体（示例） ---------- */
// src/entities/device.entity.ts
import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from "typeorm";
@Entity()
export class Device {
  @PrimaryGeneratedColumn('increment') id: number;
  @Column({ unique: true }) code: string;
  @Column() name: string;
  @Column({ nullable: true }) category: string;
  @Column({ nullable: true }) location_id: number;
  @Column({ nullable: true }) manufacturer: string;
  @Column({ nullable: true }) model: string;
  @Column({ nullable: true }) serial_no: string;
  @Column({ type: 'date', nullable: true }) purchase_date: string;
  @Column({ default: 'in_service' }) status: string;
  @Column({ type: 'jsonb', nullable: true }) metadata: any;
  @CreateDateColumn() created_at: Date;
  @UpdateDateColumn() updated_at: Date;
}
// 省略其它实体，按上面 SQL 映射
/* ---------- Express 简单路由（示例） ---------- */
import express from 'express';
import bodyParser from 'body-parser';
import { createConnection, getRepository } from 'typeorm';
import cron from 'node-cron';
import { Device } from './entities/device.entity';
import { RepairTicket } from './entities/repair_ticket.entity';
import { InspectionPlan } from './entities/inspection_plan.entity';
import { InspectionRecord } from './entities/inspection_record.entity';
import { MaintenanceRecord } from './entities/maintenance_record.entity';
async function main() {
  await createConnection(); // 请在 ormconfig.json 配置数据库连接
  const app = express();
  app.use(bodyParser.json());
  // 设备：创建与列表
  app.post('/api/devices', async (req, res) => {
    const repo = getRepository(Device);
    const { code, name, category, location_id } = req.body;
    if (!code || !name) return res.status(400).json({ message: 'code/name 必填' });
    try {
      const exists = await repo.findOne({ where: { code }});
      if (exists) return res.status(400).json({ message: '设备编码已存在' });
      const d = repo.create({ code, name, category, location_id });
      await repo.save(d);
      return res.json(d);
    } catch (e) { return res.status(500).json({ message: 'error', e }); }
  });
  app.get('/api/devices', async (req, res) => {
    const repo = getRepository(Device);
    const list = await repo.find({ take: 200 });
    res.json(list);
  });
  // 报修：新建、指派、关闭（简化）
  app.post('/api/tickets', async (req, res) => {
    const repo = getRepository(RepairTicket);
    const { device_id, description, reporter_id, priority } = req.body;
    const ticketNo = `T${Date.now()}`;
    const t = repo.create({ ticket_no: ticketNo, device_id, description, reporter_id, priority, status: 'reported' });
    await repo.save(t);
    // 这里可以 publish 到消息队列用于派单
    res.json(t);
  });
  app.post('/api/tickets/:id/assign', async (req, res) => {
    const repo = getRepository(RepairTicket);
    const ticket = await repo.findOne(req.params.id);
    if (!ticket) return res.status(404).send('ticket not found');
    ticket.assigned_to = req.body.assigned_to;
    ticket.status = 'assigned';
    await repo.save(ticket);
    res.json(ticket);
  });
  // 巡检计划：创建、列表
  app.post('/api/inspection/plans', async (req, res) => {
    const repo = getRepository(InspectionPlan);
    const p = repo.create(req.body);
    await repo.save(p);
    // 如果需要，可以在这里把计划注册到实际 cron
    res.json(p);
  });
  app.get('/api/inspection/plans', async (req, res) => {
    const repo = getRepository(InspectionPlan);
    res.json(await repo.find());
  });
  // 巡检记录（移动端同步）
  app.post('/api/inspection/records', async (req, res) => {
    const repo = getRepository(InspectionRecord);
    // local_id 用于离线同步幂等
    const r = repo.create(req.body);
    await repo.save(r);
    // 如果记录包含异常，自动生成工单（示例）
    const hasIssue = (r.result && JSON.stringify(r.result).includes('"status":"issue"'));
    if (hasIssue) {
      const ticketRepo = getRepository(RepairTicket);
      const ticket = ticketRepo.create({
        ticket_no: `T${Date.now()}`,
        device_id: r.device_id,
        description: `巡检发现异常: ${JSON.stringify(r.result)}`,
        reporter_id: r.inspector_id,
        priority: 2
      });
      await ticketRepo.save(ticket);
    }
    res.json(r);
  });
  // 保养记录
  app.post('/api/maintenance', async (req, res) => {
    const repo = getRepository(MaintenanceRecord);
    const m = repo.create(req.body);
    await repo.save(m);
    res.json(m);
  });
  // 简单搜索接口
  app.get('/api/search', async (req, res) => {
    const repo = getRepository(Device);
    const q = req.query.q as string || '';
    const list = await repo.createQueryBuilder('d')
      .where('d.name ILIKE :q OR d.code ILIKE :q', { q: `%${q}%` })
      .limit(100).getMany();
    res.json(list);
  });
  // 启动定时任务：扫描 active inspection_plan 并生成任务（示例；生产请做更稳健的实现）
  cron.schedule('* * * * *', async () => {
    const planRepo = getRepository(InspectionPlan);
    const plans = await planRepo.find({ where: { active: true }});
    for (const p of plans) {
      if (!p.cron_expr) continue;
      // 生产中建议把计划解析成独立 cron 任务注册，而非每分钟扫描 DB
      // 这里简化：若 cron_expr 匹配当前分钟则生成任务（伪逻辑）
      // TODO: 使用 cron-parser 或者在启动时注册每个计划的 cron job
    }
  });
  app.listen(3000, () => console.log('server started on 3000'));
}
main().catch(e => console.error(e));
/* ---------- 前端调用示例（浏览器 fetch） ---------- */
// 提交报修
fetch('/api/tickets', { method:'POST', headers:{'Content-Type':'application/json'},
  body: JSON.stringify({ device_id: 1, description: '电机异常振动', reporter_id: 1001, priority: 1 })
}).then(r=>r.json()).then(console.log);
// 移动端离线后同步巡检记录（带 local_id）
fetch('/api/inspection/records', { method:'POST', headers:{'Content-Type':'application/json'},
  body: JSON.stringify({
    plan_id: 2,
    device_id: 1,
    inspector_id: 1001,
    result: [{ item: '温度', value: '75C', status: 'ok' }, { item: '振动', value: '高', status: 'issue' }],
    status: 'issue',
    local_id: 'mobile-uuid-xxxx'
  })
}).then(r=>r.json()).then(console.log);