คู่มือมาตรฐานข้อมูลทางการแพทย์ (Medical Data Standards Guide)

สำหรับระบบ MediTech Hospital Information System

Document Version: 1.0
Date: September 2, 2025
Project: MediTech HIS - Healthcare Data Interoperability
Prepared by: Medical Technology Systems Team

สารบัญ (Table of Contents)

บทนำ (Introduction)
HL7 Version 2.x
HL7 Version 3
FHIR (Fast Healthcare Interoperability Resources)
การเปรียบเทียบมาตรฐาน (Standards Comparison)
การนำไปใช้ใน MediTech (Implementation in MediTech)
มาตรฐานอื่นๆ ที่เกี่ยวข้อง (Related Standards)
Best Practices และข้อแนะนำ

1. บทนำ (Introduction)

1.1 ความสำคัญของมาตรฐานข้อมูลทางการแพทย์

มาตรฐานข้อมูลทางการแพทย์เป็นหัวใจสำคัญของการแลกเปลี่ยนข้อมูลระหว่างระบบสุขภาพต่างๆ โดยมีความจำเป็นและเหตุผลสำคัญดังนี้:

🔗 ปัญหาที่เกิดขึ้นโดยไม่มีมาตรฐาน

สำหรับ Development Team:

ความซับซ้อนในการบูรณาการ (Integration Complexity)
ต้องเขียน custom adapter สำหรับแต่ละระบบ เช่น:
- Lab System A ส่งข้อมูลเป็น CSV format
- Lab System B ส่งข้อมูลเป็น XML แต่ schema ต่างกัน
- Pharmacy System ใช้ proprietary API
เวลาพัฒนาเพิ่มขึ้น 3-5 เท่าตัว สำหรับแต่ละ integration
ไม่สามารถ reuse code ได้ ทำให้ codebase บานปลาย
การบำรุงรักษาที่ยาก (Maintenance Nightmare)
แต่ละ interface มี bug และ edge case ต่างกัน
เมื่อ vendor อัปเดต API ต้องแก้ไข custom code ทุกครั้ง
Documentation กระจัดกระจาย ไม่มีมาตรฐาน
Testing ต้องทำแยกสำหรับแต่ละระบบ
ข้อผิดพลาดในการแปลงข้อมูล (Data Transformation Errors)

ตัวอย่างปัญหาจริง:

// Lab System A: glucose = "120 mg/dL"
// Lab System B: glucose = 120 (หน่วยเป็น mg/dL)
// Lab System C: glucose = 6.7 (หน่วยเป็น mmol/L)

การแปลงหน่วยผิดอาจทำให้แพทย์วินิจฉัยผิด
Date format ต่างกัน (DD/MM/YYYY vs MM/DD/YYYY)
Character encoding issues (UTF-8 vs TIS-620)
ขาดการตรวจสอบความถูกต้อง (No Validation)
ไม่มี schema validation
Business rules ไม่ชัดเจน
ข้อมูลผิดรูปแบบผ่านเข้าระบบได้
ตรวจพบข้อผิดพลาดช้า (ที่ user interface)

สำหรับ Healthcare Operations:

ความล่าช้าในการรักษา (Treatment Delays)
หมอต้องรอผลแลปจาก 3 ระบบ ใช้เวลา 15-30 นาที
ข้อมูล vital signs ไม่ real-time
การ approve ยาต้องผ่านหลายขั้นตอน manual
Emergency case ถูกชะลอเพราะข้อมูลไม่พร้อม
ความผิดพลาดทางการแพทย์ (Medical Errors)

ตัวอย่างสถานการณ์จริง:

Scenario: ผู้ป่วยมีประวัติแพ้ Penicillin
- ข้อมูลอยู่ในระบบ A แต่หมอดูจากระบบ B
- หมอสั่งยาที่มี Penicillin
- ผู้ป่วยเกิดอาการแพ้รุนแรง

Duplicate orders เพราะข้อมูลไม่ sync
Wrong patient identification
Medication dosage errors
การทำงานซ้ำซ้อน (Redundant Work)
พยาบาลกรอกข้อมูล vital signs 3 ระบบ
ข้อมูลผู้ป่วยถูกกรอกซ้ำที่แต่ละแผนก
Manual transcription จาก paper ไป digital
Double entry เพื่อ verification
การติดตามผู้ป่วยที่ไม่ต่อเนื่อง (Fragmented Care)
ไม่มี single source of truth
Timeline การรักษาไม่ชัดเจน
การส่งต่อผู้ป่วยข้อมูลสูญหาย
Follow-up care ไม่ต่อเนื่อง

💡 เหตุผลที่ต้องใช้มาตรฐาน

1. การแลกเปลี่ยนข้อมูล (Interoperability)

มาตรฐานข้อมูลทางการแพทย์ช่วยให้ระบบต่างๆ สามารถสื่อสารกันได้อย่างมีประสิทธิภาพ:

Semantic Interoperability (ความเข้าใจในระดับความหมาย)
ระบบต่างๆ เข้าใจความหมายของข้อมูลเหมือนกัน
ตัวอย่าง: "Blood Pressure" ใน FHIR หมายถึง "ความดันโลหิต" เสมอ
การใช้ terminology standards เช่น SNOMED CT, LOINC
ลดความคลุมเครือในการตีความข้อมูล
Syntactic Interoperability (ความเข้ากันได้ในระดับโครงสร้าง)
รูปแบบข้อมูลที่เป็นมาตรฐานเดียวกัน
JSON schema สำหรับ FHIR, HL7 message format
การ validate ข้อมูลตาม schema อัตโนมัติ
ลดข้อผิดพลาดในการแปลงข้อมูล
Technical Interoperability (ความเข้ากันได้ทางเทคนิค)
การเชื่อมต่อทางเทคนิคที่เข้ากันได้
RESTful APIs, MLLP protocols, WebSocket connections
Authentication และ authorization standards
Network protocols และ message queuing

2. ความถูกต้องของข้อมูล (Data Integrity)

มาตรฐานช่วยรับรองความถูกต้องและความน่าเชื่อถือของข้อมูล:

Schema Validation (การตรวจสอบรูปแบบ)

// ตัวอย่าง FHIR validation
const patientSchema = {
  resourceType: 'Patient',
  required: ['identifier', 'name', 'gender'],
  properties: {
    birthDate: { type: 'string', pattern: '^[0-9]{4}-[0-9]{2}-[0-9]{2}$' }
  }
};

ตรวจสอบรูปแบบข้อมูลตามมาตรฐานโดยอัตโนมัติ
Reject ข้อมูลที่ไม่ถูกต้องก่อนเข้าระบบ
Consistent data types และ formats

Business Rules (กฎทางธุรกิจ)

// ตัวอย่าง business rules
if (patient.age < 18 && !patient.guardian) {
  throw new Error('Minor patient requires guardian information');
}

if (medication.dosage > medication.maxDailyDose) {
  throw new Error('Dosage exceeds maximum daily limit');
}

กฎเกณฑ์ทางธุรกิจที่ได้รับการยอมรับระหว่างประเทศ
Clinical decision support rules
Drug interaction checking
Error Detection (การตรวจจับข้อผิดพลาด)
ระบบตรวจจับข้อผิดพลาดได้อัตโนมัติและแบบ real-time
Data quality monitoring และ reporting
Automatic error correction mechanisms
Alert systems สำหรับข้อมูลที่ผิดปกติ

3. ความปลอดภัย (Security)

มาตรฐานมีกลไกการรักษาความปลอดภัยที่แข็งแกร่ง:

Standardized Encryption (การเข้ารหัสมาตรฐาน)

// FHIR OAuth 2.0 + SMART on FHIR
const authConfig = {
  encryption: 'AES-256-GCM',
  tokenExpiry: 3600, // 1 hour
  refreshTokenExpiry: 86400, // 24 hours
  scope: 'patient/*.read practitioner/*.read'
};

TLS 1.3 สำหรับ data in transit
AES-256 สำหรับ data at rest
Digital signatures สำหรับ data integrity
Access Control (การควบคุมการเข้าถึง)
Role-based access control (RBAC)
Attribute-based access control (ABAC)
Fine-grained permissions บน resource level
Patient consent management

Audit Trails (การติดตามการใช้งาน)

interface AuditEvent {
  timestamp: Date;
  actor: User;
  action: 'create' | 'read' | 'update' | 'delete';
  resource: FHIRResource;
  outcome: 'success' | 'failure';
  sourceIP: string;
}

Complete audit logs ของการเข้าถึงข้อมูล
Tamper-proof logging mechanisms
GDPR และ HIPAA compliance

4. ประสิทธิภาพ (Efficiency)

การใช้มาตรฐานช่วยเพิ่มประสิทธิภาพในการพัฒนาและดำเนินงาน:

Reduced Development Time (ลดเวลาพัฒนา)

# แทนที่จะเขียน custom parser
npm install @types/fhir
npm install node-hl7-complete

# ใช้เวลาพัฒนา: 2 วัน แทนที่จะเป็น 2 สัปดาห์

พร้อม libraries และ SDKs สำหรับทุกภาษา
Code generators และ development tools
Extensive documentation และ examples
Lower Integration Costs (ต้นทุนการเชื่อมต่อต่ำ)
ลดจำนวน custom adapters ที่ต้องพัฒนา
Vendor independence - เปลี่ยน vendor ได้ง่าย
Standardized testing procedures
Reduced maintenance overhead

Faster Data Access (เข้าถึงข้อมูลเร็วขึ้น)

// FHIR Search API - ค้นหาผู้ป่วยได้ใน 1 request
GET /Patient?identifier=1234567890&_include=Patient:general-practitioner

// แทนที่จะต้อง query หลาย tables/systems

Optimized query patterns
Standardized search parameters
Efficient data serialization formats
Built-in pagination และ filtering

5. มาตรฐานคุณภาพและการปฏิบัติตาม (Quality & Compliance)

Healthcare Quality Metrics
CQMs (Clinical Quality Measures) reporting
HEDIS (Healthcare Effectiveness Data and Information Set)
Value-based care metrics
Regulatory Compliance
FDA 21 CFR Part 11 compliance
HIPAA Security และ Privacy Rules
European GDPR requirements
Local regulations (PDPA ในประเทศไทย)

6. Innovation และ Future-Proofing

API Economy
Third-party app development
Healthcare marketplace integration
Telemedicine platforms
AI/ML Integration
Structured data สำหรับ machine learning
Clinical decision support systems
Predictive analytics
Interoperability Networks
Health Information Exchanges (HIEs)
National health networks
Cross-border healthcare data sharing

📊 ตัวอย่างผลกระทบจริงในโรงพยาบาล

graph LR
    subgraph "Without Standards"
        A1[Lab System<br/>Custom Format] -.->|Manual Entry| B1[EMR System]
        C1[Radiology<br/>DICOM Only] -.->|Print & Scan| B1
        D1[Pharmacy<br/>Excel Files] -.->|Phone Call| B1
        B1 -.->|Fax| E1[External Hospital]

        style A1 fill:#ffcccc
        style C1 fill:#ffcccc
        style D1 fill:#ffcccc
        style E1 fill:#ffcccc
    end

    subgraph "With Standards"
        A2[Lab System<br/>HL7 v2.x] <-->|Automated| B2[EMR System<br/>FHIR]
        C2[Radiology<br/>DICOM + HL7] <-->|Real-time| B2
        D2[Pharmacy<br/>FHIR] <-->|API| B2
        B2 <-->|FHIR Bundle| E2[External Hospital]

        style A2 fill:#ccffcc
        style B2 fill:#ccffcc
        style C2 fill:#ccffcc
        style D2 fill:#ccffcc
        style E2 fill:#ccffcc
    end

1.2 ภาพรวมมาตรฐานหลัก

graph TD
    A[Medical Data Standards] --> B[HL7 Family]
    A --> C[Other Standards]

    B --> D[HL7 v2.x<br/>Message-based]
    B --> E[HL7 v3<br/>XML-based]
    B --> F[FHIR<br/>RESTful API]

    C --> G[DICOM<br/>Medical Imaging]
    C --> H[ICD-10<br/>Diagnosis Coding]
    C --> I[LOINC<br/>Lab Results]
    C --> J[SNOMED CT<br/>Clinical Terms]

2. HL7 Version 2.x

2.1 ภาพรวม HL7 v2.x

HL7 (Health Level Seven) Version 2.x เป็นมาตรฐานที่ใช้กันอย่างแพร่หลายที่สุดในการแลกเปลี่ยนข้อมูลทางคลินิก โดยใช้รูปแบบข้อความ (text-based messages)

2.2 โครงสร้างข้อความ HL7 v2.x

Message Structure:

MSH|^~\&|SendingApp|SendingFacility|ReceivingApp|ReceivingFacility|20250902120000||ADT^A01|MSG00001|P|2.5
EVN|A01|20250902120000
PID|1||123456789^^^Hospital^MR||ใจดี^สมชาย^^^^^L||19850615|M||Thai|123 หมู่ 5 ถ.สุขุมวิท^^กรุงเทพ^^10110^TH||(66)021234567|(66)021234567||Buddhist|Single||1234567890123|||||||||||
PV1|1|I|ICU^101^A^Hospital||||^แพทย์^นพ.สมศักดิ์||||||||||||||||||||||||||||||||||||20250902120000

Segment Breakdown:

MSH (Message Header): ข้อมูลส่วนหัวของข้อความ
EVN (Event Type): ประเภทของเหตุการณ์
PID (Patient Identification): ข้อมูลผู้ป่วย
PV1 (Patient Visit): ข้อมูลการเข้ารับบริการ

2.3 Message Types ที่สำคัญ

Message Type	Description	Usage in Healthcare
ADT	Admission, Discharge, Transfer	จัดการการรับ-จำหน่ายผู้ป่วย
ORM	Order Message	สั่งการตรวจทางห้องปฏิบัติการ
ORU	Observation Result	ส่งผลการตรวจ
SIU	Scheduling Information	นัดหมายผู้ป่วย
MDM	Medical Document Management	จัดการเอกสารทางการแพทย์

2.4 ตัวอย่างการใช้งานใน TypeScript

// HL7 v2.x Parser Example for MediTech
interface HL7Message {
  segments: Map<string, HL7Segment>;
  messageType: string;
  messageControlId: string;
}

interface HL7Segment {
  name: string;
  fields: string[];
}

class HL7Parser {
  private readonly fieldSeparator = '|';
  private readonly componentSeparator = '^';

  parse(message: string): HL7Message {
    const lines = message.split('\r');
    const segments = new Map<string, HL7Segment>();

    lines.forEach(line => {
      if (line.length > 0) {
        const fields = line.split(this.fieldSeparator);
        const segmentName = fields[0];

        segments.set(segmentName, {
          name: segmentName,
          fields: fields.slice(1)
        });
      }
    });

    const mshSegment = segments.get('MSH');
    const messageType = mshSegment?.fields[7] || '';
    const messageControlId = mshSegment?.fields[8] || '';

    return {
      segments,
      messageType,
      messageControlId
    };
  }

  // สร้าง ADT^A01 (Patient Admission) Message
  createAdmissionMessage(patient: Patient, visit: Visit): string {
    const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace('T', '').split('.')[0];
    const messageId = `MSG${Date.now()}`;

    const msh = `MSH|^~\\&|MediTech|Hospital|ReceivingApp|Facility|${timestamp}||ADT^A01|${messageId}|P|2.5`;
    const evn = `EVN|A01|${timestamp}`;
    const pid = `PID|1||${patient.hn}^^^Hospital^MR||${patient.lastName}^${patient.firstName}||${patient.birthDate}|${patient.gender}||Thai|||||||${patient.nationalId}`;
    const pv1 = `PV1|1|${visit.type}|${visit.ward}^${visit.bed}||||${visit.doctor}||||||||||||${visit.visitNumber}|||||||||||||||||||||||${timestamp}`;

    return [msh, evn, pid, pv1].join('\r');
  }
}

2.5 ข้อดีและข้อจำกัดของ HL7 v2.x

ข้อดี: - ✅ ใช้งานแพร่หลายทั่วโลก - ✅ รองรับการทำงานแบบ real-time - ✅ ขนาดข้อความเล็ก ประหยัด bandwidth - ✅ มี library รองรับหลายภาษา

ข้อจำกัด: - ❌ โครงสร้างไม่ยืดหยุ่น - ❌ ไม่มี schema validation ในตัว - ❌ การ customize ทำได้ยาก - ❌ ไม่รองรับ RESTful API โดยตรง

3. HL7 Version 3

3.1 ภาพรวม HL7 v3

HL7 Version 3 ใช้ XML เป็นพื้นฐาน และมีโครงสร้างที่เป็นระบบมากขึ้น ใช้ Reference Information Model (RIM) เป็นแกนกลาง

3.2 โครงสร้าง XML ของ HL7 v3

<?xml version="1.0" encoding="UTF-8"?>
<PRPA_IN201301UV02 xmlns="urn:hl7-org:v3" 
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <id root="2.16.840.1.113883.19.1122" extension="MSG00001"/>
  <creationTime value="20250902120000"/>
  <versionCode code="3.0"/>
  <interactionId root="2.16.840.1.113883.1.6" extension="PRPA_IN201301UV02"/>

  <receiver typeCode="RCV">
    <device classCode="DEV" determinerCode="INSTANCE">
      <id root="2.16.840.1.113883.19.1122.1"/>
      <name>MediTech HIS</name>
    </device>
  </receiver>

  <sender typeCode="SND">
    <device classCode="DEV" determinerCode="INSTANCE">
      <id root="2.16.840.1.113883.19.1122.2"/>
      <name>External System</name>
    </device>
  </sender>

  <controlActProcess classCode="CACT" moodCode="EVN">
    <subject typeCode="SUBJ">
      <registrationEvent classCode="REG" moodCode="EVN">
        <subject1 typeCode="SBJ">
          <patient classCode="PAT">
            <id root="2.16.840.1.113883.19.1122.5" extension="123456789"/>
            <patientPerson>
              <name>
                <given>สมชาย</given>
                <family>ใจดี</family>
              </name>
              <birthTime value="19850615"/>
              <administrativeGenderCode code="M" codeSystem="2.16.840.1.113883.5.1"/>
            </patientPerson>
          </patient>
        </subject1>
      </registrationEvent>
    </subject>
  </controlActProcess>
</PRPA_IN201301UV02>

3.3 CDA (Clinical Document Architecture)

CDA เป็นส่วนหนึ่งของ HL7 v3 ที่ใช้สำหรับแลกเปลี่ยนเอกสารทางคลินิก

<?xml version="1.0" encoding="UTF-8"?>
<ClinicalDocument xmlns="urn:hl7-org:v3">
  <typeId root="2.16.840.1.113883.1.3" extension="POCD_HD000040"/>
  <templateId root="2.16.840.1.113883.10.20.22.1.1"/>
  <id root="2.16.840.1.113883.19.5" extension="DOC123456"/>

  <code code="34133-9" 
        displayName="Summary of episode note" 
        codeSystem="2.16.840.1.113883.6.1" 
        codeSystemName="LOINC"/>

  <title>Discharge Summary</title>
  <effectiveTime value="20250902120000"/>

  <recordTarget>
    <patientRole>
      <id extension="123456789" root="2.16.840.1.113883.19.5"/>
      <patient>
        <name>
          <given>สมชาย</given>
          <family>ใจดี</family>
        </name>
      </patient>
    </patientRole>
  </recordTarget>

  <component>
    <structuredBody>
      <component>
        <section>
          <title>Chief Complaint</title>
          <text>Chest pain for 3 days</text>
        </section>
      </component>
    </structuredBody>
  </component>
</ClinicalDocument>

4. FHIR (Fast Healthcare Interoperability Resources)

4.1 ภาพรวม FHIR

FHIR (ออกเสียงว่า "Fire") เป็นมาตรฐานรุ่นใหม่ที่พัฒนาโดย HL7 ใช้ RESTful API และรองรับ JSON/XML ทำให้ง่ายต่อการพัฒนาและบูรณาการ

4.2 หลักการสำคัญของ FHIR

Resources: หน่วยข้อมูลพื้นฐาน (Patient, Observation, Medication)
RESTful API: ใช้ HTTP methods (GET, POST, PUT, DELETE)
Bundles: การรวมหลาย resources เข้าด้วยกัน
Profiles: การปรับแต่ง resources ให้เหมาะกับบริบท
Extensions: การเพิ่มข้อมูลที่ไม่มีในมาตรฐาน

4.3 FHIR Resources ที่สำคัญ

graph LR
    A[FHIR Resources] --> B[Foundation]
    A --> C[Clinical]
    A --> D[Financial]
    A --> E[Workflow]

    B --> B1[Patient]
    B --> B2[Organization]
    B --> B3[Practitioner]

    C --> C1[Observation]
    C --> C2[Condition]
    C --> C3[MedicationRequest]
    C --> C4[Procedure]

    D --> D1[Claim]
    D --> D2[Coverage]

    E --> E1[Appointment]
    E --> E2[Encounter]
    E --> E3[Task]

4.4 ตัวอย่าง FHIR Patient Resource (JSON)

{
  "resourceType": "Patient",
  "id": "123456789",
  "meta": {
    "versionId": "1",
    "lastUpdated": "2025-09-02T12:00:00Z",
    "profile": ["http://hl7.org/fhir/StructureDefinition/Patient"]
  },
  "identifier": [
    {
      "use": "official",
      "type": {
        "coding": [{
          "system": "http://terminology.hl7.org/CodeSystem/v2-0203",
          "code": "MR",
          "display": "Medical Record Number"
        }]
      },
      "system": "http://hospital.meditech.com/identifier/mrn",
      "value": "123456789"
    },
    {
      "use": "official",
      "type": {
        "coding": [{
          "system": "http://terminology.hl7.org/CodeSystem/v2-0203",
          "code": "NI",
          "display": "National ID"
        }]
      },
      "system": "http://thailand.gov/identifier/national-id",
      "value": "1234567890123"
    }
  ],
  "active": true,
  "name": [
    {
      "use": "official",
      "text": "นายสมชาย ใจดี",
      "family": "ใจดี",
      "given": ["สมชาย"]
    }
  ],
  "telecom": [
    {
      "system": "phone",
      "value": "+66821234567",
      "use": "mobile"
    },
    {
      "system": "email",
      "value": "[email protected]"
    }
  ],
  "gender": "male",
  "birthDate": "1985-06-15",
  "address": [
    {
      "use": "home",
      "type": "physical",
      "text": "123 หมู่ 5 ถ.สุขุมวิท แขวงคลองตัน เขตคลองเตย กรุงเทพฯ 10110",
      "line": ["123 หมู่ 5", "ถ.สุขุมวิท"],
      "city": "กรุงเทพมหานคร",
      "district": "คลองเตย",
      "postalCode": "10110",
      "country": "TH"
    }
  ],
  "maritalStatus": {
    "coding": [{
      "system": "http://terminology.hl7.org/CodeSystem/v3-MaritalStatus",
      "code": "M",
      "display": "Married"
    }]
  },
  "contact": [
    {
      "relationship": [{
        "coding": [{
          "system": "http://terminology.hl7.org/CodeSystem/v2-0131",
          "code": "N",
          "display": "Next-of-Kin"
        }]
      }],
      "name": {
        "text": "นางสาวสมหญิง ใจดี"
      },
      "telecom": [{
        "system": "phone",
        "value": "+66823456789"
      }]
    }
  ]
}

4.5 FHIR RESTful API Operations

Basic CRUD Operations:

// TypeScript Example for MediTech FHIR Client
import axios from 'axios';

class FHIRClient {
  private baseURL: string;
  private headers: any;

  constructor(baseURL: string, accessToken?: string) {
    this.baseURL = baseURL;
    this.headers = {
      'Content-Type': 'application/fhir+json',
      'Accept': 'application/fhir+json'
    };

    if (accessToken) {
      this.headers['Authorization'] = `Bearer ${accessToken}`;
    }
  }

  // CREATE - สร้าง Patient ใหม่
  async createPatient(patient: any): Promise<any> {
    const response = await axios.post(
      `${this.baseURL}/Patient`,
      patient,
      { headers: this.headers }
    );
    return response.data;
  }

  // READ - อ่านข้อมูล Patient
  async getPatient(id: string): Promise<any> {
    const response = await axios.get(
      `${this.baseURL}/Patient/${id}`,
      { headers: this.headers }
    );
    return response.data;
  }

  // UPDATE - อัปเดต Patient
  async updatePatient(id: string, patient: any): Promise<any> {
    const response = await axios.put(
      `${this.baseURL}/Patient/${id}`,
      patient,
      { headers: this.headers }
    );
    return response.data;
  }

  // DELETE - ลบ Patient
  async deletePatient(id: string): Promise<void> {
    await axios.delete(
      `${this.baseURL}/Patient/${id}`,
      { headers: this.headers }
    );
  }

  // SEARCH - ค้นหา Patients
  async searchPatients(params: any): Promise<any> {
    const response = await axios.get(
      `${this.baseURL}/Patient`,
      { 
        headers: this.headers,
        params: params 
      }
    );
    return response.data;
  }

  // BATCH/TRANSACTION - ส่งหลาย operations พร้อมกัน
  async transaction(bundle: any): Promise<any> {
    const response = await axios.post(
      `${this.baseURL}`,
      bundle,
      { headers: this.headers }
    );
    return response.data;
  }
}

// ตัวอย่างการใช้งาน
const fhirClient = new FHIRClient('https://api.meditech.com/fhir/r4');

// ค้นหาผู้ป่วยด้วย National ID
const searchParams = {
  identifier: '1234567890123',
  _format: 'json'
};

fhirClient.searchPatients(searchParams)
  .then(bundle => {
    console.log(`Found ${bundle.total} patients`);
    bundle.entry?.forEach((entry: any) => {
      console.log(`Patient: ${entry.resource.name[0].text}`);
    });
  });

4.6 FHIR Bundle Example (Transaction)

{
  "resourceType": "Bundle",
  "type": "transaction",
  "entry": [
    {
      "fullUrl": "urn:uuid:61ebe359-bfdc-4613-8bf2-c5e300945f0a",
      "resource": {
        "resourceType": "Patient",
        "identifier": [{
          "system": "http://hospital.meditech.com/identifier/mrn",
          "value": "123456789"
        }],
        "name": [{
          "use": "official",
          "family": "ใจดี",
          "given": ["สมชาย"]
        }],
        "gender": "male",
        "birthDate": "1985-06-15"
      },
      "request": {
        "method": "POST",
        "url": "Patient"
      }
    },
    {
      "fullUrl": "urn:uuid:88f151c0-a954-468a-88bd-5ae15c08e059",
      "resource": {
        "resourceType": "Encounter",
        "status": "in-progress",
        "class": {
          "system": "http://terminology.hl7.org/CodeSystem/v3-ActCode",
          "code": "AMB",
          "display": "ambulatory"
        },
        "subject": {
          "reference": "urn:uuid:61ebe359-bfdc-4613-8bf2-c5e300945f0a"
        },
        "period": {
          "start": "2025-09-02T09:00:00Z"
        }
      },
      "request": {
        "method": "POST",
        "url": "Encounter"
      }
    }
  ]
}

4.7 FHIR Subscription for Real-time Updates

{
  "resourceType": "Subscription",
  "status": "active",
  "criteria": "Patient?identifier=1234567890123",
  "channel": {
    "type": "websocket",
    "endpoint": "wss://api.meditech.com/fhir/websocket",
    "payload": "application/fhir+json"
  }
}

5. การเปรียบเทียบมาตรฐาน (Standards Comparison)

5.1 ตารางเปรียบเทียบ HL7 v2.x, HL7 v3, และ FHIR

Feature	HL7 v2.x	HL7 v3	FHIR
รูปแบบข้อมูล	Pipe-delimited text	XML	JSON/XML
Protocol	MLLP/TCP	SOAP	RESTful API
ความซับซ้อน	ปานกลาง	สูง	ต่ำ
ความยืดหยุ่น	จำกัด	ปานกลาง	สูง
Learning Curve	ปานกลาง	สูงมาก	ต่ำ
การรองรับ Mobile	ไม่ดี	ไม่ดี	ดีมาก
Real-time Support	ดี	ปานกลาง	ดีมาก (WebSocket)
การใช้งานในปัจจุบัน	แพร่หลายมาก	น้อย	เพิ่มขึ้นอย่างรวดเร็ว
Developer-friendly	ปานกลาง	ต่ำ	สูงมาก
ขนาดข้อมูล	เล็ก	ใหญ่	ปานกลาง

5.2 เมื่อใดควรใช้มาตรฐานใด

flowchart TD
    A[Choose Standard] --> B{New System?}

    B -->|Yes| C[FHIR R4]
    B -->|No| D{Legacy Integration?}

    D -->|Yes| E{What Protocol?}
    D -->|No| C

    E -->|MLLP/TCP| F[HL7 v2.x]
    E -->|SOAP/XML| G[HL7 v3]
    E -->|REST API| C

    C --> H[Modern & Scalable]
    F --> I[Wide Compatibility]
    G --> J[Complex Requirements]

6. การนำไปใช้ใน MediTech (Implementation in MediTech)

6.1 Architecture Overview

graph TB
    subgraph "MediTech Core System"
        A[MediTech HIS<br/>PostgreSQL + Nest.js]
        B[FHIR Server<br/>HAPI FHIR]
        C[HL7 Interface Engine<br/>Mirth Connect]
    end

    subgraph "Internal Systems"
        D[Laboratory<br/>HL7 v2.x]
        E[Radiology<br/>DICOM + HL7]
        F[Pharmacy<br/>FHIR R4]
    end

    subgraph "External Systems"
        G[NHSO API<br/>REST/SOAP]
        H[Other Hospitals<br/>FHIR/HL7]
        I[Mobile Apps<br/>FHIR REST]
    end

    A <--> B
    A <--> C

    C <--> D
    C <--> E
    B <--> F

    B <--> G
    B <--> H
    B <--> I

6.2 Implementation Strategy

Phase 1: Internal Integration (HL7 v2.x)

// MediTech HL7 v2.x Integration Service
@Injectable()
export class HL7IntegrationService {
  constructor(
    private readonly hl7Parser: HL7Parser,
    private readonly patientService: PatientService,
    private readonly visitService: VisitService
  ) {}

  async processADTMessage(message: string): Promise<void> {
    const parsedMessage = this.hl7Parser.parse(message);

    switch (parsedMessage.messageType) {
      case 'ADT^A01': // Admission
        await this.handleAdmission(parsedMessage);
        break;
      case 'ADT^A03': // Discharge
        await this.handleDischarge(parsedMessage);
        break;
      case 'ADT^A08': // Update patient
        await this.handlePatientUpdate(parsedMessage);
        break;
    }
  }

  private async handleAdmission(message: HL7Message): Promise<void> {
    const pidSegment = message.segments.get('PID');
    const pv1Segment = message.segments.get('PV1');

    // Extract patient data
    const patient = {
      hn: pidSegment?.fields[2].split('^')[0],
      firstName: pidSegment?.fields[4].split('^')[1],
      lastName: pidSegment?.fields[4].split('^')[0],
      birthDate: pidSegment?.fields[6],
      gender: pidSegment?.fields[7]
    };

    // Create or update patient
    await this.patientService.upsert(patient);

    // Create visit
    const visit = {
      patientHN: patient.hn,
      admissionDate: pv1Segment?.fields[43],
      ward: pv1Segment?.fields[2].split('^')[0],
      bed: pv1Segment?.fields[2].split('^')[1]
    };

    await this.visitService.create(visit);
  }
}

Phase 2: External Integration (FHIR R4)

// MediTech FHIR Integration Service
@Injectable()
export class FHIRIntegrationService {
  private fhirClient: FHIRClient;

  constructor(
    @Inject('FHIR_CONFIG') private config: FHIRConfig,
    private readonly patientService: PatientService
  ) {
    this.fhirClient = new FHIRClient(config.baseURL, config.accessToken);
  }

  // Transform MediTech Patient to FHIR Patient
  async exportPatientToFHIR(patientId: string): Promise<any> {
    const patient = await this.patientService.findById(patientId);

    const fhirPatient = {
      resourceType: 'Patient',
      identifier: [
        {
          system: 'http://hospital.meditech.com/identifier/mrn',
          value: patient.hn
        },
        {
          system: 'http://thailand.gov/identifier/national-id',
          value: patient.nationalId
        }
      ],
      name: [{
        use: 'official',
        family: patient.lastName,
        given: [patient.firstName]
      }],
      gender: patient.gender.toLowerCase(),
      birthDate: patient.birthDate,
      address: [{
        use: 'home',
        text: patient.address,
        city: patient.city,
        postalCode: patient.postalCode,
        country: 'TH'
      }],
      telecom: [
        {
          system: 'phone',
          value: patient.phone,
          use: 'mobile'
        }
      ]
    };

    return await this.fhirClient.createPatient(fhirPatient);
  }

  // Import FHIR Patient to MediTech
  async importPatientFromFHIR(fhirPatientId: string): Promise<void> {
    const fhirPatient = await this.fhirClient.getPatient(fhirPatientId);

    const patient = {
      hn: this.extractIdentifier(fhirPatient, 'MR'),
      nationalId: this.extractIdentifier(fhirPatient, 'NI'),
      firstName: fhirPatient.name?.[0]?.given?.[0] || '',
      lastName: fhirPatient.name?.[0]?.family || '',
      gender: fhirPatient.gender?.toUpperCase() || 'U',
      birthDate: fhirPatient.birthDate,
      phone: this.extractTelecom(fhirPatient, 'phone'),
      email: this.extractTelecom(fhirPatient, 'email'),
      address: fhirPatient.address?.[0]?.text || ''
    };

    await this.patientService.upsert(patient);
  }

  private extractIdentifier(patient: any, type: string): string {
    const identifier = patient.identifier?.find(
      (id: any) => id.type?.coding?.[0]?.code === type
    );
    return identifier?.value || '';
  }

  private extractTelecom(patient: any, system: string): string {
    const telecom = patient.telecom?.find(
      (t: any) => t.system === system
    );
    return telecom?.value || '';
  }
}

6.3 MediTech API Gateway Configuration

// API Gateway routes for different standards
@Controller('api/v1/integration')
export class IntegrationController {
  constructor(
    private readonly hl7Service: HL7IntegrationService,
    private readonly fhirService: FHIRIntegrationService
  ) {}

  // HL7 v2.x endpoint
  @Post('hl7/v2')
  @Header('Content-Type', 'x-application/hl7-v2+er7')
  async receiveHL7Message(@Body() message: string): Promise<string> {
    await this.hl7Service.processADTMessage(message);

    // Return HL7 ACK message
    const ackMessage = this.generateACK(message, 'AA');
    return ackMessage;
  }

  // FHIR endpoint
  @Post('fhir/Patient')
  @Header('Content-Type', 'application/fhir+json')
  async createFHIRPatient(@Body() patient: any): Promise<any> {
    const result = await this.fhirService.importPatientFromFHIR(patient.id);

    return {
      resourceType: 'OperationOutcome',
      issue: [{
        severity: 'information',
        code: 'informational',
        details: {
          text: 'Patient imported successfully'
        }
      }]
    };
  }

  // Webhook for real-time updates
  @Post('webhook/fhir')
  async handleFHIRWebhook(@Body() notification: any): Promise<void> {
    // Process FHIR subscription notification
    if (notification.resourceType === 'Bundle') {
      for (const entry of notification.entry) {
        await this.processFHIRResource(entry.resource);
      }
    }
  }
}

7.1 DICOM (Digital Imaging and Communications in Medicine)

สำหรับการจัดการภาพทางการแพทย์:

// DICOM Integration Example
interface DICOMStudy {
  studyInstanceUID: string;
  patientID: string;
  patientName: string;
  studyDate: string;
  modality: string;
  studyDescription: string;
  series: DICOMSeries[];
}

interface DICOMSeries {
  seriesInstanceUID: string;
  seriesDescription: string;
  modality: string;
  instances: DICOMInstance[];
}

interface DICOMInstance {
  sopInstanceUID: string;
  instanceNumber: number;
  imageURL: string;
}

7.2 ICD-10 (International Classification of Diseases)

สำหรับการลงรหัสโรค:

{
  "code": "I21.0",
  "display": "Acute transmural myocardial infarction of anterior wall",
  "displayThai": "กล้ามเนื้อหัวใจตายเฉียบพลันชนิดเต็มความหนาของผนังหัวใจส่วนหน้า",
  "category": "I21",
  "chapter": "IX"
}

7.3 LOINC (Logical Observation Identifiers Names and Codes)

สำหรับผลการตรวจทางห้องปฏิบัติการ:

{
  "code": "2160-0",
  "display": "Creatinine [Mass/volume] in Serum or Plasma",
  "displayThai": "ครีเอตินินในซีรัมหรือพลาสมา",
  "unit": "mg/dL",
  "normalRange": {
    "male": "0.7-1.3",
    "female": "0.6-1.1"
  }
}

7.4 SNOMED CT (Systematized Nomenclature of Medicine Clinical Terms)

สำหรับคำศัพท์ทางคลินิก:

{
  "conceptId": "22298006",
  "term": "Myocardial infarction",
  "termThai": "กล้ามเนื้อหัวใจตาย",
  "semanticTag": "disorder",
  "hierarchy": [
    "404684003|Clinical finding",
    "118234003|Finding by site",
    "301095005|Cardiac finding"
  ]
}

8. Best Practices และข้อแนะนำ

8.1 Security Best Practices

1. Authentication & Authorization

// OAuth 2.0 for FHIR
const fhirAuthConfig = {
  authorizationURL: 'https://auth.meditech.com/oauth/authorize',
  tokenURL: 'https://auth.meditech.com/oauth/token',
  clientId: process.env.FHIR_CLIENT_ID,
  clientSecret: process.env.FHIR_CLIENT_SECRET,
  scopes: ['patient/*.read', 'patient/*.write', 'launch/patient']
};

2. Audit Logging

// Audit all data exchanges
@Injectable()
export class IntegrationAuditService {
  async logDataExchange(
    standard: 'HL7v2' | 'HL7v3' | 'FHIR',
    operation: string,
    resourceType: string,
    resourceId: string,
    userId: string,
    success: boolean,
    details?: any
  ): Promise<void> {
    await this.auditRepository.create({
      timestamp: new Date(),
      standard,
      operation,
      resourceType,
      resourceId,
      userId,
      success,
      details,
      ipAddress: this.getClientIP(),
      userAgent: this.getUserAgent()
    });
  }
}

8.2 Performance Optimization

1. Caching Strategy

// Redis caching for frequently accessed FHIR resources
@Injectable()
export class FHIRCacheService {
  constructor(
    @InjectRedis() private readonly redis: Redis
  ) {}

  async getCachedResource(
    resourceType: string, 
    id: string
  ): Promise<any> {
    const key = `fhir:${resourceType}:${id}`;
    const cached = await this.redis.get(key);

    if (cached) {
      return JSON.parse(cached);
    }

    return null;
  }

  async setCachedResource(
    resourceType: string,
    id: string,
    resource: any,
    ttl: number = 3600
  ): Promise<void> {
    const key = `fhir:${resourceType}:${id}`;
    await this.redis.setex(key, ttl, JSON.stringify(resource));
  }
}

2. Batch Processing

// Batch FHIR transactions for better performance
async function batchFHIROperations(operations: any[]): Promise<any> {
  const bundle = {
    resourceType: 'Bundle',
    type: 'batch',
    entry: operations.map(op => ({
      resource: op.resource,
      request: {
        method: op.method,
        url: op.url
      }
    }))
  };

  return await fhirClient.transaction(bundle);
}

8.3 Error Handling

// Comprehensive error handling for integration
class IntegrationErrorHandler {
  handleError(error: any, context: string): void {
    if (error.response) {
      // FHIR OperationOutcome
      if (error.response.data.resourceType === 'OperationOutcome') {
        const issues = error.response.data.issue;
        issues.forEach((issue: any) => {
          console.error(`FHIR Error [${issue.severity}]: ${issue.details?.text}`);
        });
      }
      // HL7 v2.x NAK
      else if (error.message.includes('NAK')) {
        console.error('HL7 Message rejected:', error.message);
      }
    } else if (error.request) {
      // Network error
      console.error(`Network error in ${context}:`, error.message);
      // Implement retry logic
      this.scheduleRetry(context, error);
    } else {
      // Other errors
      console.error(`Unexpected error in ${context}:`, error.message);
    }
  }

  private scheduleRetry(context: string, error: any): void {
    // Exponential backoff retry
    const retryDelay = Math.min(1000 * Math.pow(2, error.retryCount || 0), 30000);
    setTimeout(() => {
      // Retry operation
    }, retryDelay);
  }
}

8.4 Testing Strategies

// Integration testing for different standards
describe('Healthcare Standards Integration', () => {
  describe('HL7 v2.x', () => {
    it('should parse ADT^A01 message correctly', () => {
      const message = 'MSH|^~\\&|...';
      const parsed = hl7Parser.parse(message);

      expect(parsed.messageType).toBe('ADT^A01');
      expect(parsed.segments.get('PID')).toBeDefined();
    });
  });

  describe('FHIR R4', () => {
    it('should validate Patient resource', async () => {
      const patient = {
        resourceType: 'Patient',
        identifier: [{ system: 'test', value: '123' }]
      };

      const result = await fhirValidator.validate(patient);
      expect(result.isValid).toBe(true);
    });
  });
});

8.5 Migration Path

flowchart LR
    A[Current System<br/>Custom Format] --> B[Phase 1<br/>HL7 v2.x Internal]
    B --> C[Phase 2<br/>FHIR Internal APIs]
    C --> D[Phase 3<br/>FHIR External]
    D --> E[Phase 4<br/>Full FHIR]

    style A fill:#f9f,stroke:#333,stroke-width:2px
    style E fill:#9f9,stroke:#333,stroke-width:2px

สรุป (Conclusion)

การเลือกใช้มาตรฐานข้อมูลทางการแพทย์ที่เหมาะสมเป็นปัจจัยสำคัญในความสำเร็จของระบบ MediTech HIS:

ข้อแนะนำสำหรับ MediTech:

ใช้ FHIR R4 เป็นมาตรฐานหลักสำหรับ:
External APIs
Mobile Applications
New integrations
Cloud services
คง HL7 v2.x สำหรับ:
Legacy system integration
Laboratory interfaces
Real-time messaging
หลีกเลี่ยง HL7 v3 เว้นแต่:
มีความจำเป็นเฉพาะ
ต้องการใช้ CDA documents
Implement gradually:
Start with internal systems
Test thoroughly
Monitor performance
Scale progressively

การใช้มาตรฐานที่ถูกต้องจะช่วยให้ MediTech HIS สามารถ: - ✅ แลกเปลี่ยนข้อมูลได้อย่างมีประสิทธิภาพ - ✅ ลดค่าใช้จ่ายในการบูรณาการ - ✅ เพิ่มความปลอดภัยของข้อมูล - ✅ รองรับการขยายตัวในอนาคต - ✅ สอดคล้องกับมาตรฐานสากล

References

HL7 International: https://www.hl7.org/
FHIR Documentation: https://www.hl7.org/fhir/
DICOM Standard: https://www.dicomstandard.org/
ICD-10: https://www.who.int/classifications/icd/
LOINC: https://loinc.org/
SNOMED CT: https://www.snomed.org/

Document Status: Complete
Last Updated: September 2, 2025
Next Review: March 2026