如何开发一套EHS健康安全环境管理系统中的健康管理板块？（附架构图+流程图+代码参考）

mermaid
graph TD
  User[用户（EHS 管理员 / 现场管理员 / 员工）] -->|Web/Mobile| Frontend[React / Mobile App]
  Frontend --> API[API 网关 / 后端服务（Node.js / Spring Boot）]
  API --> DB[(主库 PostgreSQL)]
  API --> FileStore[(对象存储：S3 / MinIO)]
  API --> Auth[(认证/授权：OAuth2 / JWT)]
  API --> JobScheduler[(定时任务：Cron / BullMQ)]
  API --> ES[(ElasticSearch，用于日志/模糊检索)]
  API --> BI[(报表/看板服务，Grafana 或 内置)]
  subgraph Integrations
    API --> HR[HR 系统]
    API --> MES[生产系统/门禁/工牌]
    API --> Lab[体检中心接口]
  end

mermaid
flowchart TD
  A[HR/员工触发体检] --> B[体检机构上传体检报告]
  B --> C[自动导入 / 手工上传 PDF]
  C --> D[解析关键指标（如血压、肺功能等）]
  D --> E{是否异常?}
  E -- 是 --> F[标注异常、生成异常工单、发送通知给 EHS/HR/员工]
  E -- 否 --> G[更新员工健康档案]
  F --> H[跟踪复查/记录]

sql
-- 员工基本信息
CREATE TABLE employees (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  employee_no VARCHAR(64) UNIQUE NOT NULL,
  name VARCHAR(128) NOT NULL,
  gender VARCHAR(16),
  birthday DATE,
  department VARCHAR(128),
  position VARCHAR(128),
  hire_date DATE,
  mobile VARCHAR(32),
  email VARCHAR(128),
  created_at TIMESTAMP DEFAULT now(),
  updated_at TIMESTAMP DEFAULT now()
);
-- 员工健康档案（结构化+JSON）
CREATE TABLE health_profiles (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  employee_id UUID REFERENCES employees(id),
  medical_history TEXT, -- 既往史，结构化文本或 JSON
  allergies TEXT,
  occupational_exposure TEXT,
  attachments JSONB, -- 存 PDF/图像的存储路径与元数据
  last_updated TIMESTAMP DEFAULT now()
);
-- 体检结果（每次体检一条）
CREATE TABLE exam_results (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  employee_id UUID REFERENCES employees(id),
  exam_date DATE,
  exam_type VARCHAR(64), -- 入职/年度/离职/专项
  indicators JSONB, -- {"blood_pressure":"120/80","bmi":23.5, ...}
  summary TEXT,
  report_path TEXT, -- 对象存储地址
  abnormal_flags JSONB, -- {"blood_pressure":true}
  created_at TIMESTAMP DEFAULT now()
);
-- 劳保用品资料库
CREATE TABLE ppe_catalog (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  sku VARCHAR(64) UNIQUE NOT NULL,
  name VARCHAR(128),
  spec VARCHAR(128),
  unit VARCHAR(32),
  safety_standards TEXT,
  created_at TIMESTAMP DEFAULT now()
);
-- 劳保库存（实时）
CREATE TABLE ppe_stock (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  ppe_id UUID REFERENCES ppe_catalog(id),
  batch_no VARCHAR(64),
  qty INT,
  location VARCHAR(128),
  in_date DATE,
  expire_date DATE,
  created_at TIMESTAMP DEFAULT now()
);
-- 劳保领用单
CREATE TABLE ppe_issuances (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  issuance_no VARCHAR(64) UNIQUE,
  employee_id UUID REFERENCES employees(id),
  ppe_id UUID REFERENCES ppe_catalog(id),
  qty INT,
  issued_by VARCHAR(128),
  issued_at TIMESTAMP DEFAULT now(),
  purpose TEXT,
  approval_status VARCHAR(32) DEFAULT 'pending', -- pending/approved/rejected
  approval_info JSONB
);
-- 异常工单
CREATE TABLE health_alerts (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  employee_id UUID REFERENCES employees(id),
  source VARCHAR(64), -- exam/manager/auto
  alert_type VARCHAR(64),
  content TEXT,
  status VARCHAR(32) DEFAULT 'open', -- open/closed
  created_at TIMESTAMP DEFAULT now(),
  resolved_at TIMESTAMP
);

环境：Node.js 18+，Postgres，Sequelize ORM，Express
js
// app.js （入口）
const express = require('express');
const bodyParser = require('body-parser');
const { sequelize } = require('./models');
const routes = require('./routes');
const app = express();
app.use(bodyParser.json());
app.use('/api', routes);
const PORT = process.env.PORT || 3000;
sequelize.authenticate().then(()=> {
  console.log('DB connected');
  app.listen(PORT, ()=> console.log(`Server running ${PORT}`));
}).catch(err => console.error(err));
js
// models/index.js
const { Sequelize, DataTypes } = require('sequelize');
const sequelize = new Sequelize(process.env.DATABASE_URL || 'postgres://user:pass@localhost:5432/ehs', {
  logging:false
});
const Employee = sequelize.define('employee', {
  id: { type: DataTypes.UUID, primaryKey:true, defaultValue: Sequelize.literal('gen_random_uuid()') },
  employee_no: { type: DataTypes.STRING, unique:true },
  name: DataTypes.STRING,
  department: DataTypes.STRING,
  position: DataTypes.STRING,
});
const HealthProfile = sequelize.define('health_profile', {
  id: { type: DataTypes.UUID, primaryKey:true, defaultValue: Sequelize.literal('gen_random_uuid()') },
  medical_history: DataTypes.TEXT,
  allergies: DataTypes.TEXT,
  attachments: DataTypes.JSONB
});
const ExamResult = sequelize.define('exam_result', {
  id: { type: DataTypes.UUID, primaryKey:true, defaultValue: Sequelize.literal('gen_random_uuid()') },
  exam_date: DataTypes.DATE,
  exam_type: DataTypes.STRING,
  indicators: DataTypes.JSONB,
  report_path: DataTypes.STRING,
  abnormal_flags: DataTypes.JSONB
});
const PpeCatalog = sequelize.define('ppe_catalog', {
  id: { type: DataTypes.UUID, primaryKey:true, defaultValue: Sequelize.literal('gen_random_uuid()') },
  sku: { type: DataTypes.STRING, unique:true },
  name: DataTypes.STRING,
  spec: DataTypes.STRING,
  unit: DataTypes.STRING
});
const PpeIssuance = sequelize.define('ppe_issuance', {
  id: { type: DataTypes.UUID, primaryKey:true, defaultValue: Sequelize.literal('gen_random_uuid()') },
  issuance_no: DataTypes.STRING,
  qty: DataTypes.INTEGER,
  purpose: DataTypes.TEXT,
  approval_status: { type: DataTypes.STRING, defaultValue:'pending' }
});
const HealthAlert = sequelize.define('health_alert', {
  id: { type: DataTypes.UUID, primaryKey:true, defaultValue: Sequelize.literal('gen_random_uuid()') },
  source: DataTypes.STRING,
  alert_type: DataTypes.STRING,
  content: DataTypes.TEXT,
  status: { type: DataTypes.STRING, defaultValue:'open' }
});
// 关系
Employee.hasOne(HealthProfile, { foreignKey:'employee_id' });
Employee.hasMany(ExamResult, { foreignKey:'employee_id' });
Employee.hasMany(PpeIssuance, { foreignKey:'employee_id' });
Employee.hasMany(HealthAlert, { foreignKey:'employee_id' });
PpeCatalog.hasMany(PpeIssuance, { foreignKey:'ppe_id' });
module.exports = { sequelize, Employee, HealthProfile, ExamResult, PpeCatalog, PpeIssuance, HealthAlert };
js
// routes/index.js
const express = require('express');
const router = express.Router();
const { Employee, ExamResult, PpeCatalog, PpeIssuance, HealthAlert, sequelize } = require('../models');
// 创建员工（示例）
router.post('/employees', async (req, res) => {
  const emp = await Employee.create(req.body);
  res.json(emp);
});
// 导入体检结果（简化）
router.post('/exam/import', async (req, res) => {
  // body: { employee_no, exam_date, exam_type, indicators, report_path }
  const t = await sequelize.transaction();
  try {
    const { employee_no, exam_date, exam_type, indicators, report_path } = req.body;
    const emp = await Employee.findOne({ where:{ employee_no }});
    if(!emp) return res.status(404).json({error:'员工不存在'});
    // 简单异常判断规则示例（血压）
    const abnormal_flags = {};
    if(indicators && indicators.blood_pressure){
      const [sys,dia] = indicators.blood_pressure.split('/').map(Number);
      if(sys>140 || dia>90) abnormal_flags.blood_pressure = true;
    }
    const exam = await ExamResult.create({ employee_id: emp.id, exam_date, exam_type, indicators, report_path, abnormal_flags }, { transaction: t });
    if(Object.keys(abnormal_flags).length>0){
      await HealthAlert.create({ employee_id: emp.id, source:'exam', alert_type:'exam_abnormal', content:`检测到异常指标: ${JSON.stringify(abnormal_flags)}` }, { transaction:t });
      // 这里可触发通知：邮件/短信/站内消息
    }
    await t.commit();
    res.json({ ok:true, exam });
  } catch(err){
    await t.rollback();
    console.error(err);
    res.status(500).json({ error: err.message });
  }
});
// PPE 领用申请（创建）
router.post('/ppe/apply', async (req, res) => {
  // body: { employee_no, sku, qty, purpose }
  const { employee_no, sku, qty, purpose } = req.body;
  const emp = await Employee.findOne({ where:{ employee_no }});
  if(!emp) return res.status(404).json({error:'员工不存在'});
  const ppe = await PpeCatalog.findOne({ where:{ sku }});
  if(!ppe) return res.status(404).json({error:'物品不存在'});
  const iss = await PpeIssuance.create({ issuance_no: `ISS-${Date.now()}`, employee_id: emp.id, ppe_id: ppe.id, qty, purpose, approval_status:'pending' });
  // 可触发审批流
  res.json(iss);
});
// 统计接口（看板）示例：体检异常人数、近 30 天 PPE 领用量
router.get('/dashboard/summary', async (req, res) => {
  const totalEmployees = await Employee.count();
  const abnormalCount = await HealthAlert.count({ where:{ alert_type:'exam_abnormal', status:'open' }});
  const recentPpe = await PpeIssuance.findAll({
    attributes:[
      'ppe_id',
      [sequelize.fn('sum', sequelize.col('qty')), 'total_qty']
    ],
    group:['ppe_id'],
    limit:10
  });
  res.json({ totalEmployees, abnormalCount, recentPpe });
});
module.exports = router;

jsx
// components/ExamUpload.jsx
import React, {useState} from 'react';
import { Upload, Button, Input, DatePicker, message } from 'antd';
import axios from 'axios';
export default function ExamUpload() {
  const [employeeNo, setEmployeeNo] = useState('');
  const [examDate, setExamDate] = useState(null);
  const [uploading, setUploading] = useState(false);
  const [file, setFile] = useState(null);
  const handleUpload = async () => {
    if(!employeeNo || !examDate || !file) return message.warn('请补充信息');
    setUploading(true);
    try{

      // 示例：先上传文件到后端（或直传 S3），然后提交结构化指标（这里简化）
      const fd = new FormData();
      fd.append('file', file);
      const r1 = await axios.post('/api/files/upload', fd);
      await axios.post('/api/exam/import', {
        employee_no: employeeNo, exam_date: examDate.format('YYYY-MM-DD'),
        exam_type: '年度', indicators: {}, report_path: r1.data.path
      });
      message.success('导入成功');
    }catch(err){ message.error('导入失败'); console.error(err); }
    setUploading(false);
  };
  return (
    <div>
      <Input placeholder="员工编号" value={employeeNo} onChange={e=>setEmployeeNo(e.target.value)} />
      <DatePicker onChange={d=>setExamDate(d)} />
      <Upload beforeUpload={f=>{ setFile(f); return false; }}>
        <Button>上传体检单 PDF</Button>
      </Upload>
      <Button type="primary" onClick={handleUpload} loading={uploading}>导入体检</Button>
    </div>
  );
}
jsx
// components/Dashboard.jsx
import React, {useEffect, useState} from 'react';
import axios from 'axios';
import { Card, Statistic, Table } from 'antd';
import { Line } from 'recharts';
export default function Dashboard() {
  const [data, setData] = useState({});
  useEffect(()=>{ axios.get('/api/dashboard/summary').then(r=>setData(r.data)); },[]);
  return (
    <div style={{display:'grid', gridTemplateColumns:'1fr 1fr', gap:16}}>
      <Card><Statistic title="员工总数" value={data.totalEmployees} /></Card>
      <Card><Statistic title="未处理体检异常" value={data.abnormalCount} /></Card>
      <Card style={{gridColumn:'1 / span 2'}}>
        <h3>最近 PPE 领用（Top10）</h3>
        <Table dataSource={data.recentPpe || []} rowKey="ppe_id">
          <Table.Column title="PPE ID" dataIndex="ppe_id" key="ppe_id" />
          <Table.Column title="领用总量" dataIndex="total_qty" key="total_qty" />
        </Table>
      </Card>
    </div>
  );
}