Desain Alur E-Prescription untuk Mencegah Resep Ganda & Salah Dosis

Pernah ngalamin dapet komplain dari farmasi gara-gara resep ganda atau dosis ngaco pas dokter entry di RME, Sobat IT RS? Atau pasien batal pulang gara-gara resep ga nyambung sama stok gudang? Waduh, bikin keringetan sendiri, apalagi pas closing klaim BPJS — bisa jadi senjata makan tuan kalau ga ketangkep validasi. Makanya, alur e-prescription (e-resep) kudu rapih, ga cuma biar keren digital doang, tapi juga biar error kayak gini ke-ban dari awal.

Sekali dua kali miss, masih bisa dimaafin. Tapi kalau tiap hari farmasi harus rollback, nurse mondar-mandir nanya, dokternya ngomel karena sistem “bikin ribet”, IT pasti kena semprot. Intinya: validasi otomatis itu wajib, khususnya pas racik resep di RME. Biar resep ganda dan salah dosis langsung ke-detect sebelum nambah kerjaan manual.

Masalah Umum di E-Prescription RS

Resep ganda: Dokter entry item obat dua kali (kadang beda dosis).
Dosis tidak sesuai: Entry melebihi atau kurang dari batas aturan pakai/terapi standar.
Obat non-stok: Obat yang diresepkan tidak ada di gudang/apotek, bikin proses lama bahkan batal tebus.
Aturan pakai tidak lengkap: Sering blank atau tidak sesuai format (misal, “3x1” padahal harus “3x1 oral setelah makan”).
Interaksi obat: Beberapa kombinasi tidak boleh, tapi sistem ga cegat.

Rata-rata, semua kasus di atas bisa dicegat pake validasi otomatis di level aplikasi sebelum order resep dikunci/dikirim. Kenapa validasi penting? Karena revisi di belakang itu selalu lebih mahal, baik waktu, tenaga, atau risiko ke pasien.

Alur E-Prescription yang Aman Versi MinTIRS

Alur gampangnya kayak gini:

Dokter entry order resep via RME (pilih obat, dosis, aturan pakai).
Sistem otomatis cek:
- Duplikasi item
- Dosis sesuai range
- Aturan pakai valid & lengkap
- Stok tersedia
- Interaksi antar-obat utama
Kalau lolos, resep bisa simpan/kirim; kalau error, user dapet feedback spesifik (“stok kurang”, “dosis melebihi maksimal”, dsb).

Jadi, IT harus rancang validasi ini otomatis, jangan andalkan farmasi buat cek manual.

Desain Struktur Tabel Kunci

1. Tabel Master Obat

CREATE TABLE master_obat (
  kode_obat VARCHAR(20) PRIMARY KEY,
  nama_obat VARCHAR(100) NOT NULL,
  satuan VARCHAR(20),
  dosis_maks DECIMAL(10,2), -- per hari
  dosis_min DECIMAL(10,2),
  tipe_obat VARCHAR(30), -- generik, paten, psikotropika, dsb
  aturan_pakai_template VARCHAR(100)
);

Field dosis_maks dan dosis_min: Untuk validasi dosis entry dokter.
aturan_pakai_template: Template aturan pakai default, bisa dipakai buat auto-fill di form entry.

2. Tabel Stok Obat

CREATE TABLE stok_obat (
  kode_obat VARCHAR(20),
  lokasi VARCHAR(20), -- gudang utama, apotek, dsb
  jumlah DECIMAL(12,2),
  tgl_update TIMESTAMP,
  PRIMARY KEY (kode_obat, lokasi)
);

Field jumlah: Perlu real-time update, sinkron dengan transaksi.

3. Tabel Order Resep (Transaksi)

CREATE TABLE order_resep (
  id_resep SERIAL PRIMARY KEY,
  no_rm VARCHAR(20),
  tgl_resep TIMESTAMP,
  kode_dokter VARCHAR(20),
  status VARCHAR(10) -- DRAFT, FINAL, BATAL
);

CREATE TABLE order_resep_detail (
  id_detail SERIAL PRIMARY KEY,
  id_resep INT REFERENCES order_resep(id_resep),
  kode_obat VARCHAR(20),
  dosis DECIMAL(10,2),
  satuan VARCHAR(10),
  jumlah_hari INT,
  aturan_pakai VARCHAR(100)
);

Kalau multi-detail (ada item ganda), bisa dicegat di level aplikasi.

Validasi Otomatis di Backend

1. Cek Duplikasi Item Obat

# Python-like pseudocode (bisa adaptasi ke JS/PHP/C#)
def cek_duplikasi(obat_list):
    kode_obats = [x['kode_obat'] for x in obat_list]
    return len(kode_obats) != len(set(kode_obats))

# Dipakai sebelum simpan order
if cek_duplikasi(order_resep_detail):
    return "Ada obat ganda di resep, cek ulang."

Optimal: validasi juga di front-end (misal JS), tapi back-end wajib cegat.

2. Validasi Dosis

# Query dosis_maks & dosis_min dari tabel master_obat
SELECT dosis_maks, dosis_min FROM master_obat WHERE kode_obat = 'OBAT001';

# Di layer aplikasi:
if dosis_entry > dosis_maks or dosis_entry < dosis_min:
    return "Dosis di luar range: min {} - maks {}".format(dosis_min, dosis_maks)

Tambahkan log audit kalau sering terjadi, bisa buat analisa user error atau perlu update master data.

3. Validasi Aturan Pakai

# Cek aturan pakai tidak kosong dan sesuai format/template
if not aturan_pakai.strip():
    return "Aturan pakai jangan kosong"

# Contoh regex sederhana: Harus ada frekuensi (3x1/2x1), rute (oral/injeksi), waktu (sebelum/sesudah makan)
import re
pattern = r'\d+x\d+\s+(oral|injeksi)\s+(sebelum|sesudah)\s+makan'
if not re.match(pattern, aturan_pakai.strip().lower()):
    return "Format aturan pakai kurang lengkap (misal: 3x1 oral sesudah makan)"

Regex bisa dikembangkan sesuai SOP RS, minimal cegat entry ngawur.

4. Validasi Stok Obat

# Ambil stok dari lokasi dispensasi
SELECT jumlah FROM stok_obat WHERE kode_obat='OBAT001' AND lokasi='apotek';

if jumlah < kebutuhan:
    return "Stok {} tidak cukup. Sisa: {}, butuh: {}".format(nama_obat, jumlah, kebutuhan)

Pastikan transaksi stok atomic, hindari race condition (pakai locking di DB atau queue request).

5. Validasi Interaksi Obat Sederhana

# Tabel master_interaksi_obat (opsional)
CREATE TABLE master_interaksi_obat (
  kode_obat1 VARCHAR(20),
  kode_obat2 VARCHAR(20),
  deskripsi VARCHAR(200),
  PRIMARY KEY (kode_obat1, kode_obat2)
);

# Pseudocode:
for item_a in resep:
    for item_b in resep:
        if item_a != item_b and ada_di_master_interaksi(item_a, item_b):
            return "Ada interaksi antara {} dan {}".format(item_a, item_b)

Implementasi simple: Hardcode beberapa larangan utama, nanti kembangkan database interaksi lebih advance.

Studi Kasus Nyata: Resep Ganda & Salah Dosis di Instalasi Rawat Inap

Pasien rawat inap, dokter entry resep Paracetamol 500mg tab, dua kali (satu entry dikasih 1 tab tiap 8 jam, satu lagi 1 tab tiap 6 jam). Farmasi notice pas closing, ternyata dua entry ini otomatis ke-print dua label, pasien hampir dapat double dosis. Kalau sistem e-resep tidak cegat, bisa fatal.

Solusi: Di backend, sebelum simpan, sistem cek apakah ada kode_obat sama dalam satu id_resep (lihat validasi duplikasi di atas). Kalau ada, blokir plus kasih warning: “Obat Paracetamol sudah ada, cek ulang dosis & frekuensi.”

Snippet Integrasi Validasi di RME

Contoh pseudo-code logic saat tombol “Kirim Resep” di RME diklik:

# 1. Panggil data order_resep_detail (dari draft/screen entry user)
items = ambil_order_resep_detail_draft(user)

# 2. Cek duplikasi
if cek_duplikasi(items):
    notif("Ada obat ganda, cek ulang")

# 3. Cek stok & dosis & aturan pakai per item
for item in items:
    stok = cek_stok(item.kode_obat, item.lokasi)
    if stok < item.jumlah_hari * item.dosis:
        notif("Stok {} kurang".format(item.nama_obat))
    dosis_maks, dosis_min = ambil_dosis_master(item.kode_obat)
    if item.dosis > dosis_maks or item.dosis < dosis_min:
        notif("Dosis {} tidak sesuai range".format(item.nama_obat))
    if not valid_aturan_pakai(item.aturan_pakai):
        notif("Aturan pakai kurang lengkap: {}".format(item.nama_obat))

# 4. Jika semua lolos, simpan & ubah status resep ke FINAL

Tips Implementasi: Biar Dokter Ga “Kapok” Pakai E-Resep

Feedback error harus jelas, bukan “Validation failed”. Tulis error user friendly, contoh: “Stok Amoxicillin kurang. Sisa: 0, butuh: 10 tablet.”
Jangan biarkan user bisa skip aturan pakai. Form entry wajib (required) & auto-fill template, bukan entry manual 100%.
Kasih saran dosis/aturan pakai default pas dokter pilih obat.
Permudah koreksi: Kalau error, highlight field bermasalah (bisa pake warna merah di UI).
Semua validasi tetap wajib di backend walau front-end sudah cegat. Banyak user iseng/“bypass” via tools (misal, Postman, plugin browser).
Catat log error validasi (siapa, entry apa, kapan) buat analisa problem user & training SDM.
Sinkronisasi stok real-time, minimal ada warning kalau stok “nyaris habis” di entry screen.
Tambahkan batch checker untuk interaksi obat, minimal warning kalau kombinasi berbahaya.

Antipola: Hindari Skenario Fatal Ini!

Entry resep tanpa validasi apa-apa, hanya depend ke farmasi buat cek manual.
Field aturan pakai bisa dikosongin/diisi bebas (free text tanpa template/regex).
Dosis entry tanpa cek min/maks, semua diterima as is.
Stok baru di cek pas pengambilan obat, bukan waktu entry resep.

Bonus: Query Monitoring Resep Error

Biar gampang analisa kasus error, bikin query monitoring ke order resep bermasalah.

-- Cari resep ganda (lebih dari 1 entry untuk kode_obat sama dalam 1 resep)
SELECT id_resep, kode_obat, COUNT(*)
FROM order_resep_detail
GROUP BY id_resep, kode_obat
HAVING COUNT(*) > 1;

-- Cek dosis di luar range
SELECT d.id_resep, d.kode_obat, d.dosis, m.dosis_min, m.dosis_maks
FROM order_resep_detail d
JOIN master_obat m ON d.kode_obat = m.kode_obat
WHERE d.dosis < m.dosis_min OR d.dosis > m.dosis_maks;

-- Cek aturan pakai kosong
SELECT id_resep, kode_obat
FROM order_resep_detail
WHERE aturan_pakai IS NULL OR TRIM(aturan_pakai) = '';

Kesimpulan Teknis

Validasi otomatis di alur e-prescription itu life saver, bukan sekadar “fitur tambahan”.
Desain dari awal: duplikasi item, stok, dosis, aturan pakai kudu dicegat sebelum simpan/finalisasi.
Jangan kasih jalan pintas ke user, tapi juga jangan bikin ribet — auto-fill, template, dan feedback jelas bikin user nurut tanpa drama.
Rajin monitoring & simpan log error buat perbaikan ke depan.

Rekap Quick-Win Implementasi

Backend validation wajib: stok, dosis, aturan pakai, duplikasi item.
Auto-fill aturan pakai berdasarkan master obat.
Regex/format checker aturan pakai.
Log semua error & warning validasi, review per bulan.
Query monitoring buat dashboard resep error.

Pokok e, jangan kasih ruang buat resep ganda dan salah dosis tembus. E-prescription itu tameng, bukan jebakan. Kalau sistem udah validasi otomatis, kerja farmasi dan nurse lebih enteng, pasien juga lebih aman. Sobat IT RS, ayo rapihin alur validasi di e-resep, biar ga dikomelin tiap closing shift!

Desain Alur E-Prescription untuk Mencegah Resep Ganda dan Salah Dosis