의료 시스템 통합

6.1 의료 정보 시스템 개요

원격 환자 모니터링 시스템이 실질적인 임상적 가치를 제공하기 위해서는 기존 의료 정보 시스템과의 원활한 통합이 필수적입니다. 이 장에서는 전자건강기록(EHR), 전자의무기록(EMR), 의료영상저장전송시스템(PACS), 처방전달시스템(CPOE) 등 다양한 의료 정보 시스템과의 통합 전략을 다룹니다.

6.1.1 의료 정보 시스템의 유형

6.1.2 시스템 통합의 필요성

6.2 HL7 FHIR 기반 통합

HL7 FHIR(Fast Healthcare Interoperability Resources)는 현대 의료 정보 교환의 표준으로 자리잡았습니다. RESTful API 기반의 접근 방식은 웹 기술에 익숙한 개발자들이 쉽게 의료 시스템 통합을 구현할 수 있게 합니다.

6.2.1 FHIR 리소스 매핑

// RPM 데이터를 FHIR Observation으로 변환
const createFHIRObservation = (vitalSign) => {
    return {
        resourceType: "Observation",
        id: generateUUID(),
        meta: {
            profile: [
                "http://hl7.org/fhir/StructureDefinition/vitalsigns"
            ],
            lastUpdated: new Date().toISOString()
        },
        status: "final",
        category: [{
            coding: [{
                system: "http://terminology.hl7.org/CodeSystem/observation-category",
                code: "vital-signs",
                display: "활력징후"
            }]
        }],
        code: {
            coding: [{
                system: "http://loinc.org",
                code: vitalSign.loincCode,
                display: vitalSign.displayName
            }],
            text: vitalSign.koreanName
        },
        subject: {
            reference: `Patient/${vitalSign.patientId}`
        },
        effectiveDateTime: vitalSign.timestamp,
        issued: new Date().toISOString(),
        performer: [{
            reference: `Device/${vitalSign.deviceId}`
        }],
        valueQuantity: {
            value: vitalSign.value,
            unit: vitalSign.unit,
            system: "http://unitsofmeasure.org",
            code: vitalSign.ucumCode
        },
        device: {
            reference: `Device/${vitalSign.deviceId}`,
            display: vitalSign.deviceName
        },
        derivedFrom: vitalSign.rawDataReference ? [{
            reference: `DocumentReference/${vitalSign.rawDataReference}`
        }] : undefined
    };
};

// 혈압 측정 데이터를 FHIR로 변환
const createBloodPressureObservation = (bpReading) => {
    return {
        resourceType: "Observation",
        id: generateUUID(),
        meta: {
            profile: [
                "http://hl7.org/fhir/StructureDefinition/bp"
            ]
        },
        status: "final",
        category: [{
            coding: [{
                system: "http://terminology.hl7.org/CodeSystem/observation-category",
                code: "vital-signs",
                display: "활력징후"
            }]
        }],
        code: {
            coding: [{
                system: "http://loinc.org",
                code: "85354-9",
                display: "Blood pressure panel"
            }],
            text: "혈압"
        },
        subject: {
            reference: `Patient/${bpReading.patientId}`
        },
        effectiveDateTime: bpReading.timestamp,
        component: [
            {
                code: {
                    coding: [{
                        system: "http://loinc.org",
                        code: "8480-6",
                        display: "Systolic blood pressure"
                    }],
                    text: "수축기 혈압"
                },
                valueQuantity: {
                    value: bpReading.systolic,
                    unit: "mmHg",
                    system: "http://unitsofmeasure.org",
                    code: "mm[Hg]"
                }
            },
            {
                code: {
                    coding: [{
                        system: "http://loinc.org",
                        code: "8462-4",
                        display: "Diastolic blood pressure"
                    }],
                    text: "이완기 혈압"
                },
                valueQuantity: {
                    value: bpReading.diastolic,
                    unit: "mmHg",
                    system: "http://unitsofmeasure.org",
                    code: "mm[Hg]"
                }
            }
        ]
    };
};

6.2.2 SMART on FHIR 앱 개발

SMART on FHIR은 EHR 시스템 내에서 실행되는 타사 애플리케이션을 위한 표준입니다. RPM 대시보드를 SMART 앱으로 개발하면 다양한 EHR 시스템과 호환됩니다.

// SMART on FHIR 클라이언트 초기화
import FHIR from 'fhirclient';

class SMARTRPMApp {
    constructor() {
        this.client = null;
        this.patient = null;
    }

    // SMART 인증 시작
    async authorize() {
        return FHIR.oauth2.authorize({
            clientId: 'wia-rpm-dashboard',
            scope: 'launch/patient patient/Observation.read patient/Observation.write',
            redirectUri: window.location.origin + '/callback'
        });
    }

    // 인증 완료 후 클라이언트 초기화
    async initializeClient() {
        this.client = await FHIR.oauth2.ready();
        this.patient = await this.client.patient.read();
        return this.patient;
    }

    // 환자의 RPM 데이터 조회
    async getPatientVitals(startDate, endDate) {
        const observations = await this.client.request(
            `Observation?patient=${this.patient.id}` +
            `&category=vital-signs` +
            `&date=ge${startDate}&date=le${endDate}` +
            `&_sort=-date&_count=100`,
            { pageLimit: 0 }
        );
        return this.processObservations(observations);
    }

    // RPM 데이터 전송
    async sendObservation(observation) {
        const response = await this.client.create(observation);
        return response;
    }

    // 관찰 데이터 처리
    processObservations(bundle) {
        if (!bundle.entry) return [];

        return bundle.entry.map(entry => {
            const obs = entry.resource;
            return {
                id: obs.id,
                type: this.getVitalType(obs.code),
                value: this.extractValue(obs),
                timestamp: obs.effectiveDateTime,
                status: obs.status
            };
        });
    }

    getVitalType(code) {
        const loincMap = {
            '8867-4': 'heartRate',
            '8310-5': 'bodyTemperature',
            '85354-9': 'bloodPressure',
            '59408-5': 'oxygenSaturation',
            '29463-7': 'bodyWeight',
            '41653-7': 'bloodGlucose'
        };
        const coding = code.coding[0];
        return loincMap[coding.code] || 'unknown';
    }

    extractValue(observation) {
        if (observation.valueQuantity) {
            return {
                value: observation.valueQuantity.value,
                unit: observation.valueQuantity.unit
            };
        }
        if (observation.component) {
            return observation.component.map(c => ({
                code: c.code.coding[0].code,
                value: c.valueQuantity.value,
                unit: c.valueQuantity.unit
            }));
        }
        return null;
    }
}

export default SMARTRPMApp;

6.3 한국 의료 정보 표준

한국에서는 보건복지부와 건강보험심사평가원, 사회보장정보원 등에서 의료 정보 표준화를 추진하고 있습니다. RPM 시스템은 이러한 국내 표준과도 호환되어야 합니다.

6.3.1 국내 의료 정보 표준

6.3.2 건강보험 청구 연동

# 원격 환자 모니터링 건강보험 청구 코드 매핑
class KoreanBillingIntegration:
    """
    한국 건강보험 청구를 위한 원격 모니터링 서비스 코드
    """

    # 원격진료 관련 수가 코드 (2024년 기준)
    TELEHEALTH_CODES = {
        'AZ001': {
            'name': '원격의료협력진료',
            'description': '비대면 진료 협력',
            'fee': 7000,
            'conditions': ['도서벽지', '의료취약지']
        },
        'AZ010': {
            'name': '원격모니터링 관리료',
            'description': '만성질환 원격 모니터링',
            'fee': 15000,
            'conditions': ['당뇨', '고혈압', '심부전']
        },
        'AZ020': {
            'name': '원격심전도 판독료',
            'description': '실시간 심전도 원격 판독',
            'fee': 25000,
            'conditions': ['부정맥', '심근경색 위험군']
        }
    }

    # RPM 서비스별 EDI 코드
    RPM_SERVICE_MAPPING = {
        'blood_pressure': {
            'edi_code': 'E1010',
            'loinc': '85354-9',
            'frequency': 'daily',
            'min_readings': 2
        },
        'blood_glucose': {
            'edi_code': 'E1020',
            'loinc': '41653-7',
            'frequency': 'daily',
            'min_readings': 3
        },
        'ecg_monitoring': {
            'edi_code': 'E1030',
            'loinc': '11524-6',
            'frequency': 'continuous',
            'min_duration_hours': 24
        },
        'oxygen_saturation': {
            'edi_code': 'E1040',
            'loinc': '59408-5',
            'frequency': 'continuous',
            'min_readings': 4
        }
    }

    def __init__(self, provider_id, facility_code):
        self.provider_id = provider_id
        self.facility_code = facility_code
        self.session_claims = []

    def create_rpm_claim(self, patient, service_type, period_start, period_end, readings):
        """
        원격 모니터링 서비스에 대한 청구 생성
        """
        service_config = self.RPM_SERVICE_MAPPING.get(service_type)
        if not service_config:
            raise ValueError(f"지원되지 않는 서비스 유형: {service_type}")

        # 최소 측정 횟수 검증
        if len(readings) < service_config.get('min_readings', 1):
            raise ValueError(
                f"청구 요건 미충족: 최소 {service_config['min_readings']}회 측정 필요"
            )

        claim = {
            'claim_id': self.generate_claim_id(),
            'provider_id': self.provider_id,
            'facility_code': self.facility_code,
            'patient': {
                'insurance_id': patient['insurance_id'],
                'name': patient['name'],
                'birth_date': patient['birth_date']
            },
            'service': {
                'edi_code': service_config['edi_code'],
                'service_type': service_type,
                'period_start': period_start,
                'period_end': period_end,
                'reading_count': len(readings)
            },
            'diagnosis': {
                'primary': patient.get('primary_diagnosis'),
                'secondary': patient.get('secondary_diagnosis', [])
            },
            'created_at': datetime.now().isoformat()
        }

        self.session_claims.append(claim)
        return claim

    def validate_claim(self, claim):
        """
        청구 유효성 검증
        """
        validations = []

        # 필수 필드 검증
        required_fields = ['patient', 'service', 'diagnosis']
        for field in required_fields:
            if field not in claim:
                validations.append({
                    'field': field,
                    'error': '필수 필드 누락',
                    'severity': 'error'
                })

        # 진단 코드 유효성
        if claim.get('diagnosis', {}).get('primary'):
            if not self.validate_kcd_code(claim['diagnosis']['primary']):
                validations.append({
                    'field': 'diagnosis.primary',
                    'error': '유효하지 않은 KCD 코드',
                    'severity': 'error'
                })

        # 서비스 기간 검증
        period_days = (
            datetime.fromisoformat(claim['service']['period_end']) -
            datetime.fromisoformat(claim['service']['period_start'])
        ).days

        if period_days > 31:
            validations.append({
                'field': 'service.period',
                'error': '청구 기간이 1개월을 초과',
                'severity': 'warning'
            })

        return {
            'valid': not any(v['severity'] == 'error' for v in validations),
            'validations': validations
        }

    def submit_to_hira(self, claims):
        """
        건강보험심사평가원 EDI 시스템으로 청구 제출
        """
        # EDI 전문 생성
        edi_message = self.create_edi_message(claims)

        # 암호화 및 전송
        encrypted = self.encrypt_message(edi_message)

        response = requests.post(
            'https://edi.hira.or.kr/api/v1/claims',
            data=encrypted,
            headers={
                'Content-Type': 'application/x-edi',
                'X-Provider-Id': self.provider_id
            },
            cert=('/path/to/cert.pem', '/path/to/key.pem')
        )

        return self.parse_edi_response(response)

6.4 EHR 연동 아키텍처

RPM 시스템과 EHR 간의 연동은 다양한 아키텍처 패턴을 통해 구현할 수 있습니다. 실시간 데이터 동기화, 배치 처리, 이벤트 기반 통합 등 요구사항에 맞는 방식을 선택해야 합니다.

┌─────────────────────────────────────────────────────────────────────┐
│                        RPM-EHR 통합 아키텍처                           │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│   ┌───────────────┐                      ┌───────────────┐         │
│   │   RPM 기기     │                      │   EHR 시스템   │         │
│   │  (환자 측)     │                      │  (의료기관)    │         │
│   └───────┬───────┘                      └───────┬───────┘         │
│           │                                      │                 │
│           │ BLE/WiFi                       FHIR API                │
│           ▼                                      │                 │
│   ┌───────────────┐                             │                 │
│   │  모바일 앱     │                             │                 │
│   │ (데이터 수집)  │                             │                 │
│   └───────┬───────┘                             │                 │
│           │                                      │                 │
│           │ HTTPS/TLS                           │                 │
│           ▼                                      ▼                 │
│   ┌─────────────────────────────────────────────────────┐         │
│   │                Integration Hub                       │         │
│   │  ┌─────────┐  ┌─────────┐  ┌─────────┐            │         │
│   │  │ API GW  │  │ 메시지  │  │  FHIR   │            │         │
│   │  │         │  │  큐     │  │  서버   │            │         │
│   │  └────┬────┘  └────┬────┘  └────┬────┘            │         │
│   │       │            │            │                  │         │
│   │       └────────────┼────────────┘                  │         │
│   │                    ▼                               │         │
│   │            ┌─────────────┐                         │         │
│   │            │   데이터    │                         │         │
│   │            │  변환 엔진  │                         │         │
│   │            └──────┬──────┘                         │         │
│   │                   │                                │         │
│   └───────────────────┼────────────────────────────────┘         │
│                       │                                           │
│                       ▼                                           │
│              ┌─────────────────┐                                  │
│              │  임상 데이터     │                                  │
│              │  저장소 (CDR)    │                                  │
│              └─────────────────┘                                  │
│                                                                   │
└───────────────────────────────────────────────────────────────────┘

6.4.1 통합 허브 구현

// Integration Hub - 메시지 라우터
class IntegrationHub {
    constructor(config) {
        this.fhirClient = new FHIRClient(config.fhir);
        this.messageQueue = new MessageQueue(config.queue);
        this.transformEngine = new DataTransformer();
        this.routingRules = new Map();
    }

    // 라우팅 규칙 등록
    registerRoute(sourceSystem, targetSystem, transformer) {
        const key = `${sourceSystem}->${targetSystem}`;
        this.routingRules.set(key, {
            transformer,
            retryPolicy: {
                maxRetries: 3,
                backoffMs: 1000
            }
        });
    }

    // 메시지 수신 및 라우팅
    async processMessage(message) {
        const { source, target, payload, metadata } = message;
        const routeKey = `${source}->${target}`;
        const route = this.routingRules.get(routeKey);

        if (!route) {
            throw new Error(`라우팅 규칙 없음: ${routeKey}`);
        }

        const traceId = uuid();
        console.log(`[${traceId}] 메시지 처리 시작: ${source} -> ${target}`);

        try {
            // 데이터 변환
            const transformed = await route.transformer.transform(payload);

            // 대상 시스템으로 전송
            const result = await this.sendToTarget(target, transformed, {
                traceId,
                originalMessage: message,
                ...route.retryPolicy
            });

            // 감사 로그 기록
            await this.auditLog({
                traceId,
                source,
                target,
                status: 'success',
                timestamp: new Date()
            });

            return result;
        } catch (error) {
            // 실패 메시지 데드레터 큐로 이동
            await this.messageQueue.sendToDeadLetter(message, error);

            await this.auditLog({
                traceId,
                source,
                target,
                status: 'failed',
                error: error.message,
                timestamp: new Date()
            });

            throw error;
        }
    }

    // 대상 시스템으로 전송
    async sendToTarget(target, data, options) {
        switch(target) {
            case 'EHR':
                return this.sendToEHR(data, options);
            case 'FHIR':
                return this.sendToFHIR(data, options);
            case 'HIRA':
                return this.sendToHIRA(data, options);
            default:
                throw new Error(`지원되지 않는 대상: ${target}`);
        }
    }

    // EHR 시스템 전송 (HL7 v2)
    async sendToEHR(data, options) {
        const hl7Message = this.transformEngine.toHL7v2(data);

        return retry(async () => {
            const response = await this.ehrConnection.send(hl7Message);
            if (response.MSA[1] !== 'AA') {
                throw new Error(`EHR 응답 오류: ${response.MSA[3]}`);
            }
            return response;
        }, options);
    }

    // FHIR 서버 전송
    async sendToFHIR(data, options) {
        const bundle = this.transformEngine.toFHIRBundle(data);

        return retry(async () => {
            return await this.fhirClient.transaction(bundle);
        }, options);
    }
}

6.4.2 데이터 변환 엔진

// 데이터 변환기
class DataTransformer {
    constructor() {
        this.mappings = new Map();
        this.validators = [];
    }

    // 변환 매핑 등록
    registerMapping(sourceFormat, targetFormat, mappingFn) {
        const key = `${sourceFormat}:${targetFormat}`;
        this.mappings.set(key, mappingFn);
    }

    // 변환 실행
    async transform(data, sourceFormat, targetFormat) {
        const key = `${sourceFormat}:${targetFormat}`;
        const mapper = this.mappings.get(key);

        if (!mapper) {
            throw new Error(`변환 매핑 없음: ${key}`);
        }

        // 입력 검증
        await this.validateInput(data, sourceFormat);

        // 변환 실행
        const result = await mapper(data);

        // 출력 검증
        await this.validateOutput(result, targetFormat);

        return result;
    }

    // RPM JSON -> FHIR Bundle 변환
    rpmToFHIRBundle(rpmData) {
        const entries = [];

        // 환자 정보
        if (rpmData.patient) {
            entries.push({
                fullUrl: `urn:uuid:${rpmData.patient.id}`,
                resource: this.createPatientResource(rpmData.patient),
                request: {
                    method: 'PUT',
                    url: `Patient/${rpmData.patient.id}`
                }
            });
        }

        // 활력징후 데이터
        for (const vital of rpmData.vitals || []) {
            const observationId = uuid();
            entries.push({
                fullUrl: `urn:uuid:${observationId}`,
                resource: this.createObservationResource(vital, rpmData.patient.id),
                request: {
                    method: 'POST',
                    url: 'Observation'
                }
            });
        }

        // 경고 이벤트
        for (const alert of rpmData.alerts || []) {
            entries.push({
                fullUrl: `urn:uuid:${uuid()}`,
                resource: this.createFlagResource(alert, rpmData.patient.id),
                request: {
                    method: 'POST',
                    url: 'Flag'
                }
            });
        }

        return {
            resourceType: 'Bundle',
            type: 'transaction',
            timestamp: new Date().toISOString(),
            entry: entries
        };
    }

    // 환자 리소스 생성
    createPatientResource(patient) {
        return {
            resourceType: 'Patient',
            id: patient.id,
            identifier: [{
                system: 'http://wia.org/rpm/patient-id',
                value: patient.id
            }],
            name: [{
                family: patient.lastName,
                given: [patient.firstName]
            }],
            birthDate: patient.birthDate,
            gender: patient.gender,
            telecom: patient.phone ? [{
                system: 'phone',
                value: patient.phone,
                use: 'mobile'
            }] : undefined,
            address: patient.address ? [{
                text: patient.address.text,
                city: patient.address.city,
                postalCode: patient.address.postalCode
            }] : undefined
        };
    }
}

6.5 실시간 데이터 동기화

중환자 모니터링이나 응급 상황에서는 실시간 데이터 동기화가 필수적입니다. WebSocket, Server-Sent Events(SSE), 또는 gRPC 스트리밍을 활용한 실시간 통합 방안을 살펴봅니다.

6.5.1 WebSocket 기반 실시간 동기화

// 실시간 RPM-EHR 동기화 서비스
import WebSocket from 'ws';

class RealtimeSyncService {
    constructor(config) {
        this.ehrWebSocket = null;
        this.rpmDataStream = null;
        this.syncBuffer = [];
        this.config = config;
    }

    // EHR WebSocket 연결
    async connectToEHR() {
        return new Promise((resolve, reject) => {
            this.ehrWebSocket = new WebSocket(this.config.ehrWsUrl, {
                headers: {
                    Authorization: `Bearer ${this.config.ehrToken}`
                }
            });

            this.ehrWebSocket.on('open', () => {
                console.log('EHR WebSocket 연결 완료');
                this.subscribeToPatients(this.config.patientIds);
                resolve();
            });

            this.ehrWebSocket.on('message', (data) => {
                this.handleEHRMessage(JSON.parse(data));
            });

            this.ehrWebSocket.on('error', (error) => {
                console.error('EHR WebSocket 오류:', error);
                reject(error);
            });

            this.ehrWebSocket.on('close', () => {
                console.log('EHR WebSocket 연결 종료');
                this.scheduleReconnect();
            });
        });
    }

    // 환자 데이터 구독
    subscribeToPatients(patientIds) {
        this.ehrWebSocket.send(JSON.stringify({
            type: 'subscribe',
            resource: 'Observation',
            criteria: {
                patient: patientIds.join(','),
                category: 'vital-signs'
            }
        }));
    }

    // RPM 데이터를 EHR로 실시간 전송
    async syncVitalToEHR(vitalData) {
        const observation = this.transformToFHIR(vitalData);

        // 긴급도에 따른 처리
        if (vitalData.priority === 'critical') {
            await this.sendImmediately(observation);
        } else {
            this.bufferAndBatch(observation);
        }
    }

    // 즉시 전송 (긴급)
    async sendImmediately(observation) {
        if (this.ehrWebSocket.readyState === WebSocket.OPEN) {
            this.ehrWebSocket.send(JSON.stringify({
                type: 'create',
                resource: observation
            }));

            // 긴급 알림 트리거
            await this.triggerAlert(observation);
        } else {
            // 오프라인 큐에 저장
            await this.offlineQueue.enqueue(observation);
        }
    }

    // 배치 버퍼링
    bufferAndBatch(observation) {
        this.syncBuffer.push(observation);

        if (this.syncBuffer.length >= this.config.batchSize) {
            this.flushBuffer();
        }
    }

    // 버퍼 플러시
    async flushBuffer() {
        if (this.syncBuffer.length === 0) return;

        const batch = this.syncBuffer.splice(0, this.config.batchSize);

        const bundle = {
            resourceType: 'Bundle',
            type: 'batch',
            entry: batch.map(obs => ({
                resource: obs,
                request: {
                    method: 'POST',
                    url: 'Observation'
                }
            }))
        };

        this.ehrWebSocket.send(JSON.stringify({
            type: 'batch',
            bundle
        }));
    }

    // EHR 메시지 처리
    handleEHRMessage(message) {
        switch(message.type) {
            case 'notification':
                this.handleEHRNotification(message);
                break;
            case 'ack':
                this.handleAcknowledgment(message);
                break;
            case 'error':
                this.handleEHRError(message);
                break;
        }
    }

    // EHR 알림 처리 (처방 변경 등)
    handleEHRNotification(notification) {
        if (notification.resource.resourceType === 'MedicationRequest') {
            // 약물 변경 알림을 환자 앱으로 전달
            this.notifyPatientApp(notification);
        }
    }
}

6.5.2 동기화 충돌 해결

// 충돌 해결 전략
class ConflictResolver {
    constructor() {
        this.strategies = new Map();
        this.defaultStrategy = 'lastWriteWins';
    }

    // 충돌 해결 전략 등록
    registerStrategy(resourceType, strategy) {
        this.strategies.set(resourceType, strategy);
    }

    // 충돌 해결
    async resolve(local, remote, resourceType) {
        const strategy = this.strategies.get(resourceType) || this.defaultStrategy;

        switch(strategy) {
            case 'lastWriteWins':
                return this.lastWriteWins(local, remote);
            case 'merge':
                return this.mergeStrategy(local, remote);
            case 'clinicalPriority':
                return this.clinicalPriorityStrategy(local, remote);
            case 'manual':
                return this.requestManualResolution(local, remote);
            default:
                throw new Error(`알 수 없는 충돌 해결 전략: ${strategy}`);
        }
    }

    // 마지막 쓰기 우선
    lastWriteWins(local, remote) {
        const localTime = new Date(local.meta?.lastUpdated || 0);
        const remoteTime = new Date(remote.meta?.lastUpdated || 0);

        return localTime > remoteTime ? local : remote;
    }

    // 필드별 병합
    mergeStrategy(local, remote) {
        const merged = { ...remote };

        // 로컬에서 변경된 필드 식별
        const localChanges = this.identifyChanges(local);

        // 병합 가능한 필드 병합
        for (const [field, value] of Object.entries(localChanges)) {
            if (!this.hasConflict(local[field], remote[field])) {
                merged[field] = value;
            } else {
                // 충돌 필드는 배열로 보존
                merged._conflicts = merged._conflicts || [];
                merged._conflicts.push({
                    field,
                    local: local[field],
                    remote: remote[field]
                });
            }
        }

        return merged;
    }

    // 임상적 중요도 기반 해결
    clinicalPriorityStrategy(local, remote) {
        // RPM에서 측정된 활력징후가 더 최신이면 우선
        if (local.category?.some(c => c.coding?.[0]?.code === 'vital-signs')) {
            if (local.device) {
                return local; // 기기에서 측정된 데이터 우선
            }
        }

        // 의사가 직접 입력한 데이터 우선
        if (remote.performer?.some(p => p.reference?.startsWith('Practitioner/'))) {
            return remote;
        }

        return this.lastWriteWins(local, remote);
    }

    // 수동 해결 요청
    async requestManualResolution(local, remote) {
        const ticket = await this.createResolutionTicket({
            local,
            remote,
            createdAt: new Date(),
            status: 'pending'
        });

        // 담당 의료진에게 알림
        await this.notifyStaff(ticket);

        throw new ConflictPendingError(
            '데이터 충돌 발생. 의료진 검토 필요.',
            ticket.id
        );
    }
}

6.6 보안 및 접근 제어

의료 정보 시스템 통합에서 보안은 가장 중요한 요소입니다. HIPAA, 개인정보보호법, 의료법 등 규정을 준수하면서 필요한 정보만 공유되도록 해야 합니다.

6.6.1 역할 기반 접근 제어 (RBAC)

// 의료 시스템 접근 제어
class HealthcareAccessControl {
    constructor() {
        this.roles = new Map();
        this.permissions = new Map();
    }

    // 역할 정의
    defineRoles() {
        this.roles.set('physician', {
            name: '담당 의사',
            permissions: [
                'patient:read:assigned',
                'patient:write:assigned',
                'observation:read:all',
                'observation:write:all',
                'medication:prescribe'
            ]
        });

        this.roles.set('nurse', {
            name: '간호사',
            permissions: [
                'patient:read:assigned',
                'observation:read:all',
                'observation:write:vitals',
                'alert:acknowledge'
            ]
        });

        this.roles.set('rpm_technician', {
            name: 'RPM 기술자',
            permissions: [
                'device:read:all',
                'device:write:configuration',
                'observation:read:device',
                'patient:read:limited'
            ]
        });

        this.roles.set('patient', {
            name: '환자',
            permissions: [
                'patient:read:self',
                'observation:read:self',
                'observation:write:self_reported'
            ]
        });

        this.roles.set('caregiver', {
            name: '보호자',
            permissions: [
                'patient:read:authorized',
                'observation:read:authorized',
                'alert:receive:authorized'
            ]
        });
    }

    // 권한 검증
    async checkPermission(user, action, resource) {
        const userRole = this.roles.get(user.role);
        if (!userRole) {
            return { allowed: false, reason: '유효하지 않은 역할' };
        }

        const permission = `${resource.type}:${action}`;

        // 정확한 권한 매칭
        if (userRole.permissions.includes(permission + ':all')) {
            return { allowed: true };
        }

        // 범위 제한 권한 검증
        if (userRole.permissions.includes(permission + ':assigned')) {
            const isAssigned = await this.checkAssignment(user, resource);
            return {
                allowed: isAssigned,
                reason: isAssigned ? null : '담당 환자가 아님'
            };
        }

        if (userRole.permissions.includes(permission + ':self')) {
            const isSelf = resource.patientId === user.patientId;
            return {
                allowed: isSelf,
                reason: isSelf ? null : '본인 데이터만 접근 가능'
            };
        }

        return { allowed: false, reason: '권한 없음' };
    }

    // 담당 환자 여부 확인
    async checkAssignment(user, resource) {
        const assignments = await this.db.query(
            'SELECT * FROM care_team WHERE provider_id = ? AND patient_id = ? AND active = true',
            [user.id, resource.patientId]
        );
        return assignments.length > 0;
    }

    // 감사 로그 기록
    async auditAccess(user, action, resource, result) {
        await this.db.insert('access_audit_log', {
            timestamp: new Date(),
            userId: user.id,
            userRole: user.role,
            action,
            resourceType: resource.type,
            resourceId: resource.id,
            patientId: resource.patientId,
            allowed: result.allowed,
            reason: result.reason,
            ipAddress: user.ipAddress,
            userAgent: user.userAgent
        });
    }
}

6.6.2 데이터 마스킹 및 익명화

// 민감 데이터 마스킹
class DataMaskingService {
    constructor() {
        this.maskingRules = new Map();
    }

    // 마스킹 규칙 정의
    defineRules() {
        // 환자 식별 정보
        this.maskingRules.set('Patient.identifier', {
            strategy: 'partial',
            visibleChars: 4,
            maskChar: '*'
        });

        this.maskingRules.set('Patient.name', {
            strategy: 'conditional',
            condition: (user) => user.role !== 'physician' && user.role !== 'nurse',
            masked: { family: '***', given: ['***'] }
        });

        this.maskingRules.set('Patient.telecom', {
            strategy: 'partial',
            visibleChars: 4,
            position: 'end'
        });

        this.maskingRules.set('Patient.address', {
            strategy: 'full',
            replacement: '[주소 비공개]'
        });
    }

    // 데이터 마스킹 적용
    maskData(resource, user) {
        const masked = JSON.parse(JSON.stringify(resource));

        for (const [path, rule] of this.maskingRules) {
            if (path.startsWith(resource.resourceType)) {
                const fieldPath = path.split('.').slice(1);
                this.applyMask(masked, fieldPath, rule, user);
            }
        }

        return masked;
    }

    // 마스킹 적용
    applyMask(obj, path, rule, user) {
        if (path.length === 0) return;

        const field = path[0];
        if (!(field in obj)) return;

        if (path.length === 1) {
            // 조건부 마스킹
            if (rule.strategy === 'conditional') {
                if (rule.condition(user)) {
                    obj[field] = rule.masked;
                }
                return;
            }

            // 전체 마스킹
            if (rule.strategy === 'full') {
                obj[field] = rule.replacement;
                return;
            }

            // 부분 마스킹
            if (rule.strategy === 'partial') {
                obj[field] = this.partialMask(
                    obj[field],
                    rule.visibleChars,
                    rule.maskChar || '*',
                    rule.position || 'start'
                );
                return;
            }
        }

        // 재귀적으로 하위 경로 처리
        if (typeof obj[field] === 'object') {
            this.applyMask(obj[field], path.slice(1), rule, user);
        }
    }

    // 부분 마스킹
    partialMask(value, visibleChars, maskChar, position) {
        if (typeof value !== 'string') return value;

        const len = value.length;
        if (len <= visibleChars) return maskChar.repeat(len);

        if (position === 'end') {
            return maskChar.repeat(len - visibleChars) + value.slice(-visibleChars);
        } else {
            return value.slice(0, visibleChars) + maskChar.repeat(len - visibleChars);
        }
    }

    // 연구용 익명화
    anonymizeForResearch(data) {
        return {
            ...data,
            // 식별자 제거
            id: this.generatePseudoId(data.id),
            identifier: undefined,
            name: undefined,
            telecom: undefined,
            address: undefined,
            // 날짜 일반화
            birthDate: this.generalizeDate(data.birthDate, 'year'),
            // 위치 일반화
            location: data.address ? {
                region: this.generalizeLocation(data.address)
            } : undefined
        };
    }
}

6.7 API 게이트웨이 설계

RPM 플랫폼의 API 게이트웨이는 외부 시스템 연동의 관문 역할을 합니다. 인증, 속도 제한, 로깅, 변환 등 다양한 기능을 제공합니다.

6.7.1 API 게이트웨이 구현

// RPM API Gateway
import express from 'express';
import rateLimit from 'express-rate-limit';
import helmet from 'helmet';

class RPMAPIGateway {
    constructor(config) {
        this.app = express();
        this.config = config;
        this.setupMiddleware();
        this.setupRoutes();
    }

    setupMiddleware() {
        // 보안 헤더
        this.app.use(helmet());

        // 요청 로깅
        this.app.use(this.requestLogger.bind(this));

        // 속도 제한
        this.app.use('/api/', rateLimit({
            windowMs: 15 * 60 * 1000, // 15분
            max: 100, // 요청 수 제한
            message: { error: '요청 한도 초과. 잠시 후 다시 시도하세요.' }
        }));

        // JSON 파싱
        this.app.use(express.json({ limit: '10mb' }));

        // 인증
        this.app.use('/api/', this.authenticate.bind(this));
    }

    setupRoutes() {
        // FHIR 엔드포인트
        this.app.use('/api/fhir', this.fhirRouter());

        // EHR 연동 엔드포인트
        this.app.use('/api/ehr', this.ehrRouter());

        // 건강보험 청구 엔드포인트
        this.app.use('/api/billing', this.billingRouter());

        // 헬스체크
        this.app.get('/health', (req, res) => {
            res.json({ status: 'healthy', timestamp: new Date() });
        });
    }

    // FHIR 라우터
    fhirRouter() {
        const router = express.Router();

        // FHIR 리소스 CRUD
        router.get('/:resourceType/:id?', async (req, res) => {
            try {
                const { resourceType, id } = req.params;
                const result = await this.fhirService.read(resourceType, id, req.query);
                res.json(result);
            } catch (error) {
                this.handleError(res, error);
            }
        });

        router.post('/:resourceType', async (req, res) => {
            try {
                const { resourceType } = req.params;
                const result = await this.fhirService.create(resourceType, req.body);
                res.status(201).json(result);
            } catch (error) {
                this.handleError(res, error);
            }
        });

        // 번들 처리
        router.post('/', async (req, res) => {
            try {
                if (req.body.resourceType === 'Bundle') {
                    const result = await this.fhirService.processBundle(req.body);
                    res.json(result);
                } else {
                    res.status(400).json({ error: '잘못된 요청' });
                }
            } catch (error) {
                this.handleError(res, error);
            }
        });

        return router;
    }

    // 인증 미들웨어
    async authenticate(req, res, next) {
        const authHeader = req.headers.authorization;

        if (!authHeader) {
            return res.status(401).json({ error: '인증 필요' });
        }

        try {
            const token = authHeader.split(' ')[1];
            const decoded = await this.tokenService.verify(token);

            req.user = decoded;
            req.permissions = await this.accessControl.getPermissions(decoded);

            next();
        } catch (error) {
            res.status(401).json({ error: '유효하지 않은 토큰' });
        }
    }

    // 요청 로깅
    requestLogger(req, res, next) {
        const startTime = Date.now();

        res.on('finish', () => {
            const duration = Date.now() - startTime;

            this.logger.info({
                method: req.method,
                path: req.path,
                statusCode: res.statusCode,
                duration,
                userId: req.user?.id,
                ip: req.ip
            });
        });

        next();
    }
}

6.8 통합 테스트 전략

의료 시스템 통합은 환자 안전에 직접적인 영향을 미치므로 철저한 테스트가 필수입니다. 단위 테스트부터 엔드투엔드 테스트까지 포괄적인 테스트 전략이 필요합니다.

6.8.1 통합 테스트 프레임워크

// 통합 테스트 스위트
import { describe, it, beforeAll, afterAll, expect } from '@jest/globals';

describe('RPM-EHR 통합 테스트', () => {
    let integrationHub;
    let mockEHR;
    let mockFHIRServer;

    beforeAll(async () => {
        // 모의 서버 시작
        mockEHR = await startMockEHR();
        mockFHIRServer = await startMockFHIR();

        integrationHub = new IntegrationHub({
            ehrUrl: mockEHR.url,
            fhirUrl: mockFHIRServer.url
        });
    });

    afterAll(async () => {
        await mockEHR.stop();
        await mockFHIRServer.stop();
    });

    describe('활력징후 동기화', () => {
        it('혈압 데이터를 FHIR Observation으로 변환해야 함', async () => {
            const bpReading = {
                patientId: 'test-patient-001',
                systolic: 120,
                diastolic: 80,
                timestamp: '2024-01-15T10:30:00Z',
                deviceId: 'bp-monitor-001'
            };

            const observation = await integrationHub.transform(
                bpReading,
                'rpm-bp',
                'fhir-observation'
            );

            expect(observation.resourceType).toBe('Observation');
            expect(observation.code.coding[0].code).toBe('85354-9');
            expect(observation.component).toHaveLength(2);
            expect(observation.component[0].valueQuantity.value).toBe(120);
            expect(observation.component[1].valueQuantity.value).toBe(80);
        });

        it('비정상 수치에 대한 Flag 리소스를 생성해야 함', async () => {
            const abnormalReading = {
                patientId: 'test-patient-001',
                systolic: 180,
                diastolic: 110,
                timestamp: '2024-01-15T10:30:00Z',
                deviceId: 'bp-monitor-001'
            };

            const result = await integrationHub.processVital(abnormalReading);

            expect(result.alerts).toHaveLength(1);
            expect(result.alerts[0].resourceType).toBe('Flag');
            expect(result.alerts[0].status).toBe('active');
            expect(result.alerts[0].code.text).toContain('고혈압');
        });
    });

    describe('EHR 동기화', () => {
        it('EHR로 데이터를 성공적으로 전송해야 함', async () => {
            const observation = createTestObservation();

            const result = await integrationHub.sendToEHR(observation);

            expect(result.status).toBe('success');
            expect(result.ehrId).toBeDefined();
        });

        it('EHR 연결 실패 시 재시도해야 함', async () => {
            mockEHR.simulateFailure(2); // 처음 2번 실패

            const observation = createTestObservation();
            const result = await integrationHub.sendToEHR(observation);

            expect(result.status).toBe('success');
            expect(result.retryCount).toBe(2);
        });

        it('최대 재시도 후 데드레터 큐로 이동해야 함', async () => {
            mockEHR.simulateFailure(10); // 계속 실패

            const observation = createTestObservation();

            await expect(
                integrationHub.sendToEHR(observation)
            ).rejects.toThrow('전송 실패');

            const deadLetterCount = await integrationHub.deadLetterQueue.count();
            expect(deadLetterCount).toBeGreaterThan(0);
        });
    });

    describe('보안 테스트', () => {
        it('인증 없이 접근 시 401을 반환해야 함', async () => {
            const response = await fetch(`${integrationHub.apiUrl}/api/fhir/Patient`);
            expect(response.status).toBe(401);
        });

        it('권한 없는 환자 데이터 접근 시 403을 반환해야 함', async () => {
            const token = createToken({ role: 'patient', patientId: 'other-patient' });

            const response = await fetch(
                `${integrationHub.apiUrl}/api/fhir/Patient/test-patient-001`,
                { headers: { Authorization: `Bearer ${token}` } }
            );

            expect(response.status).toBe(403);
        });
    });
});

6.9 장 요약

다음 장에서는 실제 의료 현장에서 RPM 시스템이 어떻게 활용되고 있는지 다양한 사례 연구를 통해 살펴보겠습니다.