{
  "resourceType": "Patient",
  "id": "example",
  "identifier": [
    {
      "system": "http://hospital.com/mrn",
      "value": "MRN12345"
    }
  ],
  "name": [
    {
      "use": "official",
      "family": "张",
      "given": ["伟"]
    }
  ],
  "gender": "male",
  "birthDate": "1980-01-15",
  "telecom": [
    {
      "system": "email",
      "value": "zhangwei@example.com"
    }
  ]
}

{
  "resourceType": "Observation",
  "status": "final",
  "category": [
    {
      "coding": [
        {
          "system": "http://terminology.hl7.org/CodeSystem/observation-category",
          "code": "vital-signs",
          "display": "生命体征"
        }
      ]
    }
  ],
  "code": {
    "coding": [
      {
        "system": "http://loinc.org",
        "code": "8480-6",
        "display": "收缩压"
      }
    ]
  },
  "subject": {
    "reference": "Patient/example"
  },
  "effectiveDateTime": "2026-04-13T10:30:00Z",
  "valueQuantity": {
    "value": 128,
    "unit": "mmHg",
    "system": "http://unitsofmeasure.org",
    "code": "mm[Hg]"
  }
}

GET /Observation?subject=Patient/123&category=vital-signs

GET /Observation?date=ge2026-01-01&date=le2026-04-13&status=final

GET /Condition?subject:Patient.name=张伟

GET /DiagnosticReport?_include=DiagnosticReport:subject

GET /Patient?_revinclude=Observation:subject

// 获取患者基本信息
async function getPatientData(patientId) {
  const response = await fetch(
    `https://api.health.org/fhir/Patient/${patientId}`,
    {
      headers: {
        'Authorization': 'Bearer ' + accessToken,
        'Accept': 'application/fhir+json'
      }
    }
  );
  return await response.json();
}

// 获取患者诊断列表
async function getPatientConditions(patientId) {
  const response = await fetch(
    `https://api.health.org/fhir/Condition?subject=Patient/${patientId}`,
    {
      headers: {
        'Authorization': 'Bearer ' + accessToken,
        'Accept': 'application/fhir+json'
      }
    }
  );
  return await response.json();
}

// 获取检验结果
async function getLabResults(patientId, dateRange) {
  const response = await fetch(
    `https://api.health.org/fhir/Observation?` +
    `subject=Patient/${patientId}&` +
    `category=laboratory&` +
    `date=ge${dateRange.start}&date=le${dateRange.end}`,
    {
      headers: {
        'Authorization': 'Bearer ' + accessToken,
        'Accept': 'application/fhir+json'
      }
    }
  );
  return await response.json();
}

interface FHIRClient {
  getPatient(id: string): Promise<Patient>;
  getMedications(patientId: string): Promise<MedicationRequest[]>;
  postObservation(observation: Observation): Promise<Observation>;
}

class HealthTrackerApp {
  private fhirClient: FHIRClient;

  async logBloodPressure(
    systolic: number,
    diastolic: number
  ): Promise<void> {
    const observation: Observation = {
      resourceType: 'Observation',
      status: 'final',
      category: [{
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/observation-category',
          code: 'vital-signs'
        }]
      }],
      code: {
        coding: [{
          system: 'http://loinc.org',
          code: '85354-9',
          display: '血压'
        }]
      },
      component: [
        {
          code: {
            coding: [{
              system: 'http://loinc.org',
              code: '8480-6',
              display: '收缩压'
            }]
          },
          valueQuantity: {
            value: systolic,
            unit: 'mmHg'
          }
        },
        {
          code: {
            coding: [{
              system: 'http://loinc.org',
              code: '8462-4',
              display: '舒张压'
            }]
          },
          valueQuantity: {
            value: diastolic,
            unit: 'mmHg'
          }
        }
      ],
      subject: {
        reference: `Patient/${this.patientId}`
      },
      effectiveDateTime: new Date().toISOString()
    };

    await this.fhirClient.postObservation(observation);
  }
}

┌─────────┐                   ┌─────────┐                   ┌─────────┐
│  患者   │                   │   EHR   │                   │  应用   │
└────┬────┘                   └────┬────┘                   └────┬────┘
     │                             │                             │
     │  1. 启动应用                  │                             │
     ├────────────────────────────>│                             │
     │                             │                             │
     │                             │  2. 重定向到授权端点           │
     │                             ├────────────────────────────>│
     │                             │                             │
     │                             │  3. 用户登录并授权             │
     │                             │<────────────────────────────┤
     │                             │                             │
     │  4. 接收授权码                │                             │
     │<────────────────────────────┤                             │
     │                             │                             │
     │  5. 用授权码交换访问令牌       │                             │
     ├────────────────────────────>│                             │
     │                             │                             │
     │  6. 返回访问令牌               │                             │
     │<────────────────────────────┤                             │
     │                             │                             │
     │  7. 使用令牌访问FHIR数据      │                             │
     ├────────────────────────────────────────────────────────>│
     │                             │                             │
     │  8. 返回健康数据               │                             │
     │<─────────────────────────────────────────────────────────┤
     │                             │                             │

class DiabetesManagementApp {
  private fhirUrl: string;
  private accessToken: string;

  async launch(): Promise<void> {
    // SMART启动
    const launchUrl = `${this.fhirUrl}/launch`;
    window.location.href = launchUrl;
  }

  async handleAuthorizationCode(code: string): Promise<void> {
    // 交换访问令牌
    const tokenResponse = await fetch(
      `${this.fhirUrl}/token`,
      {
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded'
        },
        body: new URLSearchParams({
          grant_type: 'authorization_code',
          code: code,
          redirect_uri: window.location.origin
        })
      }
    );

    const tokens = await tokenResponse.json();
    this.accessToken = tokens.access_token;

    // 获取患者数据
    await this.loadPatientData();
  }

  async loadPatientData(): Promise<void> {
    // 获取血糖历史记录
    const glucoseObservations = await fetch(
      `${this.fhirUrl}/Observation?` +
      `code=http://loinc.org|2345-7&` +
      `_sort=-date&` +
      `_count=30`,
      {
        headers: {
          'Authorization': `Bearer ${this.accessToken}`
        }
      }
    );

    const data = await glucoseObservations.json();
    this.displayGlucoseTrend(data.entry);
  }

  async logGlucoseReading(
    value: number,
    mealContext: string
  ): Promise<void> {
    const observation: Observation = {
      resourceType: 'Observation',
      status: 'final',
      category: [{
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/observation-category',
          code: 'vital-signs'
        }]
      }],
      code: {
        coding: [{
          system: 'http://loinc.org',
          code: '2345-7',
          display: '血糖'
        }]
      },
      valueQuantity: {
        value: value,
        unit: 'mg/dL'
      },
      note: [{
        text: `测量时间：${mealContext}`
      }],
      subject: {
        reference: 'Patient/{{context.patientId}}'
      },
      effectiveDateTime: new Date().toISOString()
    };

    await fetch(`${this.fhirUrl}/Observation`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.accessToken}`,
        'Content-Type': 'application/fhir+json'
      },
      body: JSON.stringify(observation)
    });
  }
}

# docker-compose.yml
version: '3.8'
services:
  fhir-server:
    image: hapiproject/hapi:latest
    ports:
      - "8080:8080"
    environment:
      - DATASOURCE_URL=jdbc:postgresql://db:5432/fhir
      - DATASOURCE_USERNAME=fhir
      - DATASOURCE_PASSWORD=fhir123
      - FHIR_VERSION=R4
    depends_on:
      - db

  db:
    image: postgres:14
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=fhir
      - POSTGRES_USER=fhir
      - POSTGRES_PASSWORD=fhir123

volumes:
  postgres_data:

interface PublicHealthMonitoring {
  // 上报阳性病例
  reportPositiveCase(
    patientId: string,
    testDate: Date
  ): Promise<void>;

  // 追踪接触者
  traceContacts(
    indexCaseId: string
  ): Promise<Patient[]>;

  // 生成流行病学报告
  generateEpiReport(
    region: string,
    dateRange: DateRange
  ): Promise<EpidemiologyReport>;
}

class COVID19MonitoringService implements PublicHealthMonitoring {
  async reportPositiveCase(
    patientId: string,
    testDate: Date
  ): Promise<void> {
    // 创建Condition资源
    const covidCondition: Condition = {
      resourceType: 'Condition',
      clinicalStatus: {
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/condition-clinical',
          code: 'active'
        }]
      },
      verificationStatus: {
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/condition-ver-status',
          code: 'confirmed'
        }]
      },
      category: [{
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/condition-category',
          code: 'encounter-diagnosis'
        }]
      }],
      code: {
        coding: [{
          system: 'http://snomed.info/sct',
          code: '840539006',
          display: 'COVID-19'
        }]
      },
      subject: {
        reference: `Patient/${patientId}`
      },
      onsetDateTime: testDate.toISOString()
    };

    await this.fhirClient.createResource(covidCondition);

    // 通知公共卫生部门
    await this.notifyPublicHealth(covidCondition);
  }

  async traceContacts(
    indexCaseId: string
  ): Promise<Patient[]> {
    // 查询同一时间段就诊的患者
    const encounters = await this.fhirClient.searchResources(
      'Encounter',
      {
        date: new Date(),
        location: this.getContactLocations()
      }
    );

    const contacts = await Promise.all(
      encounters.map(async (encounter: any) => {
        return await this.fhirClient.readReference(
          encounter.subject.reference
        );
      })
    );

    return contacts;
  }
}

query {
  Patient(id: "123") {
    name {
      family
      given
    }
    conditions {
      code {
        coding {
          display
        }
      }
      severity {
        text
      }
    }
  }
}