Upload files to "/"

This commit is contained in:
202410715266 RYAN ALI SUNAEDI 2026-11-07 23:32:04 +07:00
commit c6f31f2bd8
3 changed files with 2355 additions and 0 deletions

39
AGENTS.md Normal file
View File

@ -0,0 +1,39 @@
# AGENTS.md
## Project
Single-page dengue (DBD) pre-diagnosis app: **FastAPI + MySQL backend + one static HTML/JS frontend**. All user-facing copy is Indonesian; keep it that way. The fuzzy engine is Mamdani (min-max inference, centroid defuzzification) for DF / DHF / DSS.
## Layout
- `main.py` — the whole backend: SQLAlchemy models, DB seeding, fuzzy engine, FastAPI routes, uvicorn entrypoint.
- `index.html` — the whole frontend (inline CSS/JS; Tailwind + Font Awesome loaded from CDNs). No build step.
- `usecase.html` — standalone static documentation page with the corrected use case diagram (inline CSS/SVG/JS, no CDN). Open via `file://`; unrelated to the running app.
- `.agents/skills/design-taste-frontend/` + `skills-lock.json` — vendored third-party `taste-skill` (design workflow/tooling). Not app code; do not edit the kit's `assets/` or `scripts/`.
## Setup and run
- No `requirements.txt`, no tests, no lint/format config, no git. Install deps manually: `pip install fastapi uvicorn numpy sqlalchemy pymysql`.
- **MySQL must be reachable before startup.** Hardcoded URL at `main.py:17`: `mysql+pymysql://root:@localhost:3306/db_fuzzy_dbd` (root, empty password). There is no offline/mock mode.
- Importing `main.py` has side effects: `Base.metadata.create_all()` (`main.py:85`) and `seed_initial_data()` (`main.py:132`) run at import, so the app fails immediately if MySQL is down.
- Run: `python main.py` → http://127.0.0.1:8000 (uvicorn, `reload=True`). UI is served at `/`.
- Syntax-check without touching MySQL: `python -m py_compile main.py`.
## HTTP API
`GET /` (serves `index.html`), `GET /api/penyakit`, `POST /api/diagnosa`, `GET /api/riwayat`, `DELETE /api/riwayat/{id}`.
## Things easy to get wrong
- **Symptom codes are duplicated and must match exactly.** `daftarGejala` (`index.html:262`) vs. the keys read by `evaluasi_aturan` (`main.py:199`). Mismatch → `KeyError` on `POST /api/diagnosa`. Valid codes: `G01 G02 G04 G05 G06 G07 G10 G12 G16 G17 G18` (gaps are intentional).
- **Diagnosis text is not read from the DB.** `POST /api/diagnosa` returns the hardcoded `info_map` (`main.py:257`); `/api/penyakit` and seeding use `tb_penyakit`. Editing one does not change the other — keep both in sync.
- Classification thresholds on centroid score (`main.py:249`): `<42` → DF, `<72` → DHF, otherwise DSS.
- Membership-function breakpoints (`mu_rendah`/`mu_sedang`/`mu_tinggi`, `main.py:142`) differ from the UI labels (`Rendah ≤3`, `Sedang ≤6`). Change them together if you touch the scale.
- `TbUser` and `tb_diagnosa.user_id` exist but are unused — no auth or user endpoints; `user_id` is always null.
- Persistence uses `create_all` + runtime seeding, not migrations. Changing model columns will not alter existing tables; treat the DB as manual.
- Frontend is CDN-dependent (needs internet for styling/icons) and has no bundler.
- `index.html:242` has a duplicate `id` attribute on the `tab-penyakit` section. Harmless today; don't add another.
## Verification
No test suite exists. After changes: `python -m py_compile main.py`, then start the server and smoke-test e.g. `Invoke-RestMethod http://127.0.0.1:8000/api/penyakit`. Frontend changes must be checked manually in a browser at the running server.

1330
index.html Normal file

File diff suppressed because it is too large Load Diff

986
main.py Normal file
View File

@ -0,0 +1,986 @@
import hashlib
import hmac
import json
import os
import re
import secrets
from pathlib import Path
from datetime import datetime, timedelta
from typing import Dict, List, Optional
import numpy as np
import uvicorn
from fastapi import FastAPI, HTTPException, Depends, Header
from fastapi.responses import HTMLResponse
from pydantic import BaseModel, Field
# Konfigurasi SQLAlchemy & PyMySQL
from sqlalchemy import create_engine, Column, Integer, String, Float, Text, DateTime, ForeignKey, inspect, text
from sqlalchemy.orm import sessionmaker, relationship, Session, declarative_base
# URL Koneksi MySQL (Format: mysql+pymysql://user:password@host:port/nama_database)
# Sesuaikan 'root' dan '' (password) dengan konfigurasi lokal MySQL Anda.
# Bisa juga ditimpa lewat environment variable DATABASE_URL (misalnya untuk pengujian).
DATABASE_URL = os.environ.get("DATABASE_URL", "mysql+pymysql://root:@localhost:3306/db_fuzzy_dbd")
_connect_args = {"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
engine = create_engine(DATABASE_URL, echo=False, connect_args=_connect_args)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()
# Masa berlaku sesi login
MASA_BERLAKU_SESI = timedelta(days=7)
# Himpunan linguistik yang dipakai pada fuzzifikasi dan basis aturan
HIMPUNAN = ("Rendah", "Sedang", "Tinggi")
# Kelas output fuzzy (kurva keanggotaan output) dan penyakit yang terhubung
KODE_FUZZY_KE_PENYAKIT = {"DF": "P01", "DHF": "P02", "DSS": "P03"}
KODE_FUZZY = tuple(KODE_FUZZY_KE_PENYAKIT.keys())
# Akun admin bawaan (dibuat otomatis jika belum ada admin sama sekali)
ADMIN_DEFAULT_EMAIL = "admin@dbd.com"
ADMIN_DEFAULT_PASSWORD = "admin123"
# ==============================================================================
# DEFINISI MODEL TABEL DATABASE (ORM SQLAlchemy)
# ==============================================================================
class TbUser(Base):
__tablename__ = "tb_users"
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
name = Column(String(255), nullable=False)
email = Column(String(255), unique=True, index=True, nullable=False)
password = Column(String(255), nullable=False)
no_telp = Column(String(50))
role = Column(String(50), default="user") # 'admin' atau 'user'
alamat = Column(String(255))
umur = Column(Integer)
gender = Column(String(50))
diagnosas = relationship("TbDiagnosa", back_populates="user")
class TbSesi(Base):
__tablename__ = "tb_sesi"
token_hash = Column(String(64), primary_key=True)
user_id = Column(Integer, ForeignKey("tb_users.id"), nullable=False, index=True)
dibuat = Column(DateTime, nullable=False, default=datetime.now)
class TbPenyakit(Base):
__tablename__ = "tb_penyakit"
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
id_penyakit = Column(String(50), unique=True, nullable=False)
name = Column(String(255), nullable=False)
deskripsi = Column(Text)
solusi = Column(Text)
diagnosas = relationship("TbDiagnosa", back_populates="penyakit")
class TbGejala(Base):
__tablename__ = "tb_gejala"
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
id_gejala = Column(String(50), unique=True, nullable=False)
name = Column(String(255), nullable=False)
class TbAturan(Base):
__tablename__ = "tb_aturan"
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
id_aturan = Column(String(50), unique=True, nullable=False)
penyakit_kode = Column(String(50), nullable=False) # 'DF', 'DHF', atau 'DSS'
deskripsi_aturan = Column(Text)
# JSON: {"G01": ["Sedang", "Tinggi"], "G12": ["Rendah"], ...}
# Antar-gejala digabung AND (min), antar-himpunan dalam satu gejala digabung OR (max).
kondisi = Column(Text)
class TbDiagnosa(Base):
__tablename__ = "tb_diagnosa"
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
tanggal = Column(String(100), nullable=False)
nama_pasien = Column(String(255), nullable=False)
umur = Column(Integer)
gender = Column(String(50))
kode_penyakit = Column(String(50), nullable=False)
nama_penyakit = Column(String(255), nullable=False)
skor_centroid = Column(Float, nullable=False)
solusi = Column(Text)
# JSON: deskripsi, nilai gejala, aturan aktif, dan agregasi (untuk Lihat Detail / Cetak)
detail = Column(Text)
user_id = Column(Integer, ForeignKey("tb_users.id"), nullable=True)
penyakit_id = Column(Integer, ForeignKey("tb_penyakit.id"), nullable=True)
user = relationship("TbUser", back_populates="diagnosas")
penyakit = relationship("TbPenyakit", back_populates="diagnosas")
# Membuat tabel otomatis di MySQL jika belum ada
Base.metadata.create_all(bind=engine)
def tambah_kolom_jika_belum_ada(tabel: str, kolom: str, tipe_sql: str):
"""create_all tidak mengubah tabel lama, jadi kolom baru ditambahkan manual di sini."""
kolom_ada = {c["name"] for c in inspect(engine).get_columns(tabel)}
if kolom not in kolom_ada:
with engine.begin() as conn:
conn.execute(text(f"ALTER TABLE {tabel} ADD COLUMN {kolom} {tipe_sql}"))
print(f"[INFO] Kolom '{kolom}' ditambahkan ke tabel '{tabel}'.")
tambah_kolom_jika_belum_ada("tb_aturan", "kondisi", "TEXT")
tambah_kolom_jika_belum_ada("tb_diagnosa", "detail", "TEXT")
# Dependency untuk mendapatkan sesi database
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
# ==============================================================================
# KEAMANAN: HASH PASSWORD & TOKEN SESI
# ==============================================================================
def hash_password(password: str) -> str:
iterasi = 200_000
salt = secrets.token_hex(16)
dk = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt.encode("utf-8"), iterasi)
return f"pbkdf2_sha256${iterasi}${salt}${dk.hex()}"
def verifikasi_password(password: str, tersimpan: str) -> bool:
try:
algoritma, iterasi, salt, hash_hex = tersimpan.split("$")
if algoritma != "pbkdf2_sha256":
return False
dk = hashlib.pbkdf2_hmac("sha256", password.encode("utf-8"), salt.encode("utf-8"), int(iterasi))
return hmac.compare_digest(dk.hex(), hash_hex)
except (ValueError, AttributeError):
return False
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode("utf-8")).hexdigest()
# ==============================================================================
# DATA MASTER AWAL (SEEDER)
# ==============================================================================
DEFAULT_PENYAKIT = [
{
"id_penyakit": "P01",
"name": "Dengue Fever (DF)",
"deskripsi": "Demam dengue (Dengue Fever) adalah bentuk ringan dari infeksi virus dengue. Gejalanya meliputi demam tinggi mendadak, sakit kepala parah, nyeri di belakang mata, nyeri otot dan sendi, serta ruam kulit.",
"solusi": "Perawatan meliputi istirahat cukup, minum banyak cairan untuk menghindari dehidrasi, dan obat pereda nyeri seperti parasetamol. Hindari aspirin dan ibuprofen karena dapat memicu perdarahan."
},
{
"id_penyakit": "P02",
"name": "Dengue Hemorrhagic Fever (DHF)",
"deskripsi": "Demam berdarah dengue (DHF) adalah bentuk yang lebih parah ditandai dengan perdarahan (mimisan, gusi berdarah, bintik merah), penurunan jumlah trombosit (trombositopenia), dan kebocoran plasma.",
"solusi": "Memerlukan perawatan di rumah sakit untuk pemantauan ketat, terapi cairan intravena (infus) guna mengatasi kebocoran plasma, pemantauan kadar trombosit, serta transfusi darah jika diperlukan."
},
{
"id_penyakit": "P03",
"name": "Dengue Shock Syndrome (DSS)",
"deskripsi": "Dengue Shock Syndrome (DSS) adalah tahap paling parah akibat kebocoran plasma berat yang menyebabkan kegagalan sirkulasi darah (syok), nadi cepat dan lemah, serta kulit dingin.",
"solusi": "PERINGATAN DARURAT: Memerlukan perawatan intensif segera di Unit Perawatan Intensif (ICU). Manajemen cairan intravena agresif dan pemantauan hemodinamik ketat sangat diperlukan untuk mencegah komplikasi fatal."
},
]
DEFAULT_GEJALA = [
("G01", "Demam tinggi mendadak"),
("G02", "Sakit kepala berat"),
("G04", "Nyeri di belakang bola mata (retro-orbital)"),
("G05", "Mual dan muntah"),
("G06", "Nyeri tulang dan sendi (artralgia)"),
("G07", "Ruam kemerahan pada kulit"),
("G10", "Perdarahan mukosa / bintik merah (petekie)"),
("G12", "Perdarahan hidung (mimisan) / gusi berdarah"),
("G16", "Penurunan jumlah trombosit (trombositopenia)"),
("G17", "Kebocoran plasma / peningkatan hematokrit"),
("G18", "Nadi lemah cepat, gelisah, kulit dingin (tanda syok)"),
]
_ST = ["Sedang", "Tinggi"]
DEFAULT_ATURAN = [
{"id_aturan": "A01", "penyakit_kode": "DF",
"deskripsi_aturan": "Demam, Sakit Kepala, Nyeri Mata & Sendi Sedang/Tinggi TANPA Perdarahan/Syok",
"kondisi": {"G01": _ST, "G02": _ST, "G04": _ST, "G06": _ST, "G12": ["Rendah"], "G18": ["Rendah"]}},
{"id_aturan": "A02", "penyakit_kode": "DF",
"deskripsi_aturan": "Demam, Mual, & Ruam Sedang/Tinggi TANPA Trombositopenia/Syok",
"kondisi": {"G01": _ST, "G05": _ST, "G07": _ST, "G16": ["Rendah"], "G18": ["Rendah"]}},
{"id_aturan": "A03", "penyakit_kode": "DHF",
"deskripsi_aturan": "Demam Tinggi, Petekie, & Mimisan Disertai Trombositopenia Tinggi",
"kondisi": {"G01": ["Tinggi"], "G10": _ST, "G12": _ST, "G16": ["Tinggi"], "G18": ["Rendah"]}},
{"id_aturan": "A04", "penyakit_kode": "DHF",
"deskripsi_aturan": "Demam, Petekie, Trombositopenia, & Kebocoran Plasma Awal",
"kondisi": {"G01": _ST, "G10": _ST, "G16": ["Tinggi"], "G17": _ST, "G18": ["Rendah"]}},
{"id_aturan": "A05", "penyakit_kode": "DSS",
"deskripsi_aturan": "Perdarahan, Trombositopenia, Kebocoran Plasma, & Tanda Syok Tinggi",
"kondisi": {"G12": _ST, "G16": ["Tinggi"], "G17": ["Tinggi"], "G18": ["Tinggi"]}},
{"id_aturan": "A06", "penyakit_kode": "DSS",
"deskripsi_aturan": "Demam Turun Mendadak (Fase Kritis) Disertai Syok & Kebocoran Plasma",
"kondisi": {"G01": ["Rendah"], "G16": ["Tinggi"], "G17": ["Tinggi"], "G18": ["Tinggi"]}},
]
def seed_initial_data():
db = SessionLocal()
try:
# Cek apakah tabel penyakit sudah ada isinya
if db.query(TbPenyakit).count() == 0:
db.add_all([TbPenyakit(**p) for p in DEFAULT_PENYAKIT])
db.commit()
print("[INFO] Data master penyakit berhasil di-seed ke database.")
if db.query(TbGejala).count() == 0:
db.add_all([TbGejala(id_gejala=kode, name=nama) for kode, nama in DEFAULT_GEJALA])
db.commit()
print("[INFO] Data master gejala berhasil di-seed ke database.")
if db.query(TbAturan).count() == 0:
db.add_all([
TbAturan(id_aturan=a["id_aturan"], penyakit_kode=a["penyakit_kode"],
deskripsi_aturan=a["deskripsi_aturan"], kondisi=json.dumps(a["kondisi"]))
for a in DEFAULT_ATURAN
])
db.commit()
print("[INFO] Basis aturan fuzzy berhasil di-seed ke database.")
else:
bawaan_map = {a["id_aturan"]: a["kondisi"] for a in DEFAULT_ATURAN}
diperbarui = False
for row in db.query(TbAturan).all():
if not row.kondisi and row.id_aturan in bawaan_map:
row.kondisi = json.dumps(bawaan_map[row.id_aturan])
diperbarui = True
if diperbarui:
db.commit()
if db.query(TbUser).filter(TbUser.role == "admin").count() == 0:
akun = db.query(TbUser).filter(TbUser.email == ADMIN_DEFAULT_EMAIL).first()
if akun:
akun.role = "admin"
if not (akun.password or "").startswith("pbkdf2_sha256$"):
akun.password = hash_password(ADMIN_DEFAULT_PASSWORD)
else:
db.add(TbUser(name="Administrator", email=ADMIN_DEFAULT_EMAIL,
password=hash_password(ADMIN_DEFAULT_PASSWORD), role="admin"))
db.commit()
print(f"[INFO] Akun admin bawaan dibuat: {ADMIN_DEFAULT_EMAIL} / {ADMIN_DEFAULT_PASSWORD} (segera ganti password).")
except Exception as e:
print(f"[ERROR] Gagal melakukan seeder database: {e}")
finally:
db.close()
seed_initial_data()
# ==============================================================================
# MESIN INFERENSI FUZZY MAMDANI
# ==============================================================================
class FuzzyMamdaniDBD:
def __init__(self):
self.x_output = np.linspace(0, 100, 1001)
def mu_rendah(self, x: float) -> float:
if x <= 2.0:
return 1.0
elif 2.0 < x <= 3.5:
return round((3.5 - x) / 1.5, 4)
return 0.0
def mu_sedang(self, x: float) -> float:
if x <= 2.5 or x >= 7.5:
return 0.0
elif 2.5 < x < 4.5:
return round((x - 2.5) / 2.0, 4)
elif 4.5 <= x <= 5.5:
return 1.0
elif 5.5 < x < 7.5:
return round((7.5 - x) / 2.0, 4)
return 0.0
def mu_tinggi(self, x: float) -> float:
if x <= 6.0:
return 0.0
elif 6.0 < x < 8.0:
return round((x - 6.0) / 2.0, 4)
return 1.0
def kategori_linguistik(self, x: float) -> str:
if x <= 3.0:
return "Rendah"
elif x <= 6.0:
return "Sedang"
return "Tinggi"
def fuzzify_all(self, gejala: Dict[str, float]) -> Dict[str, dict]:
hasil = {}
for kode, nilai in gejala.items():
hasil[kode] = {
"nilai": nilai,
"label": self.kategori_linguistik(nilai),
"Rendah": self.mu_rendah(nilai),
"Sedang": self.mu_sedang(nilai),
"Tinggi": self.mu_tinggi(nilai)
}
return hasil
def kurva_df(self, y):
return np.where(y <= 25, 1.0, np.where(y <= 45, (45 - y) / 20.0, 0.0))
def kurva_dhf(self, y):
return np.where(
(y <= 35) | (y >= 80), 0.0,
np.where(y < 55, (y - 35) / 20.0,
np.where(y <= 65, 1.0, (80 - y) / 15.0))
)
def kurva_dss(self, y):
return np.where(y <= 70, 0.0, np.where(y < 85, (y - 70) / 15.0, 1.0))
def evaluasi_aturan(self, f: Dict[str, dict], aturan_list: List[dict]) -> list:
"""Basis aturan dibaca dari database (tb_aturan).
alpha = MIN antar-gejala dari (MAX derajat keanggotaan himpunan yang diizinkan)."""
rules = []
for a in aturan_list:
kondisi = {kode: h for kode, h in (a.get("kondisi") or {}).items() if h}
if not kondisi:
continue
alpha = min(max(f[kode][himpunan] for himpunan in daftar) for kode, daftar in kondisi.items())
rules.append({
"id_aturan": a["id_aturan"],
"penyakit": a["penyakit_kode"],
"alpha": round(alpha, 4),
"narasi": a.get("deskripsi_aturan") or ""
})
return rules
def hitung_diagnosa(self, gejala: Dict[str, float], aturan_list: List[dict]) -> dict:
# Gejala yang dipakai aturan tetapi tidak diinput dianggap bernilai 0 (tidak ada)
gejala = dict(gejala)
for a in aturan_list:
for kode in (a.get("kondisi") or {}):
gejala.setdefault(kode, 0.0)
fuzz = self.fuzzify_all(gejala)
rules = self.evaluasi_aturan(fuzz, aturan_list)
agregasi = {
kode: max([r["alpha"] for r in rules if r["penyakit"] == kode], default=0.0)
for kode in KODE_FUZZY
}
if sum(agregasi.values()) == 0:
agregasi["DF"] = 0.2
area_df = np.minimum(agregasi["DF"], self.kurva_df(self.x_output))
area_dhf = np.minimum(agregasi["DHF"], self.kurva_dhf(self.x_output))
area_dss = np.minimum(agregasi["DSS"], self.kurva_dss(self.x_output))
kurva_gabungan = np.maximum(area_df, np.maximum(area_dhf, area_dss))
total_mu = np.sum(kurva_gabungan)
skor_centroid = float(np.sum(kurva_gabungan * self.x_output) / total_mu) if total_mu > 0 else 15.0
if skor_centroid < 42.0:
kode = "DF"
elif skor_centroid < 72.0:
kode = "DHF"
else:
kode = "DSS"
return {
"kode_penyakit": kode,
"skor_centroid": round(skor_centroid, 2),
"agregasi_max": agregasi,
"rules_aktif": [r for r in rules if r["alpha"] > 0],
"fuzzifikasi": fuzz
}
agent_fuzzy = FuzzyMamdaniDBD()
# ==============================================================================
# FUNGSI BANTU
# ==============================================================================
POLA_EMAIL = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
POLA_KODE = re.compile(r"^[A-Za-z0-9_-]{1,50}$")
def baca_json(teks: Optional[str], default):
if not teks:
return default
try:
return json.loads(teks)
except (ValueError, TypeError):
return default
def normalisasi_email(email: str) -> str:
email = (email or "").strip().lower()
if not POLA_EMAIL.match(email):
raise HTTPException(status_code=400, detail="Format email tidak valid.")
return email
def normalisasi_kode(kode: str, label: str) -> str:
kode = (kode or "").strip().upper()
if not POLA_KODE.match(kode):
raise HTTPException(status_code=400, detail=f"{label} hanya boleh berisi huruf, angka, '-' atau '_' (maks. 50 karakter).")
return kode
def teks_wajib(nilai: Optional[str], label: str) -> str:
nilai = (nilai or "").strip()
if not nilai:
raise HTTPException(status_code=400, detail=f"{label} wajib diisi.")
return nilai
def teks_opsional(nilai: Optional[str]) -> Optional[str]:
nilai = (nilai or "").strip()
return nilai or None
def serialisasi_user(u: TbUser) -> dict:
return {"id": u.id, "name": u.name, "email": u.email, "role": u.role, "no_telp": u.no_telp,
"alamat": u.alamat, "umur": u.umur, "gender": u.gender}
def aturan_dari_db(db: Session) -> List[dict]:
return [{
"id": a.id,
"id_aturan": a.id_aturan,
"penyakit_kode": a.penyakit_kode,
"deskripsi_aturan": a.deskripsi_aturan,
"kondisi": baca_json(a.kondisi, {})
} for a in db.query(TbAturan).order_by(TbAturan.id_aturan).all()]
def info_penyakit(db: Session, kode_fuzzy: str):
"""Ambil info penyakit untuk kelas output fuzzy dari tb_penyakit (fallback ke data bawaan)."""
id_penyakit = KODE_FUZZY_KE_PENYAKIT[kode_fuzzy]
obj = db.query(TbPenyakit).filter(TbPenyakit.id_penyakit == id_penyakit).first()
if obj:
return obj, {"id": obj.id_penyakit, "nama": obj.name, "deskripsi": obj.deskripsi or "", "solusi": obj.solusi or ""}
bawaan = next(p for p in DEFAULT_PENYAKIT if p["id_penyakit"] == id_penyakit)
return None, {"id": id_penyakit, "nama": bawaan["name"], "deskripsi": bawaan["deskripsi"], "solusi": bawaan["solusi"]}
def serialisasi_diagnosa(r: TbDiagnosa, lengkap: bool = False) -> dict:
data = {
"id": r.id,
"tanggal": r.tanggal,
"nama_pasien": r.nama_pasien,
"umur": r.umur,
"gender": r.gender,
"kode_penyakit": r.kode_penyakit,
"nama_penyakit": r.nama_penyakit,
"skor_centroid": r.skor_centroid,
"solusi": r.solusi,
"akun": {"id": r.user.id, "name": r.user.name, "email": r.user.email} if r.user else None
}
if lengkap:
detail = baca_json(r.detail, {})
data.update({
"id_penyakit": r.penyakit.id_penyakit if r.penyakit else None,
"deskripsi": detail.get("deskripsi") or (r.penyakit.deskripsi if r.penyakit else ""),
"gejala": detail.get("gejala", []),
"rules_aktif": detail.get("rules_aktif", []),
"agregasi_max": detail.get("agregasi_max", {})
})
return data
# ==============================================================================
# AUTENTIKASI (Login, Validasi Akun, Logout)
# ==============================================================================
def get_current_user(authorization: Optional[str] = Header(default=None), db: Session = Depends(get_db)) -> TbUser:
if not authorization or not authorization.startswith("Bearer "):
raise HTTPException(status_code=401, detail="Silakan login terlebih dahulu.")
sesi = db.query(TbSesi).filter(TbSesi.token_hash == hash_token(authorization[7:].strip())).first()
if not sesi or datetime.now() - sesi.dibuat > MASA_BERLAKU_SESI:
if sesi:
db.delete(sesi)
db.commit()
raise HTTPException(status_code=401, detail="Sesi telah berakhir, silakan login kembali.")
user = db.get(TbUser, sesi.user_id)
if not user:
raise HTTPException(status_code=401, detail="Akun tidak ditemukan, silakan login kembali.")
return user
def require_admin(user: TbUser = Depends(get_current_user)) -> TbUser:
if user.role != "admin":
raise HTTPException(status_code=403, detail="Fitur ini hanya untuk Admin.")
return user
def require_user(user: TbUser = Depends(get_current_user)) -> TbUser:
if user.role != "user":
raise HTTPException(status_code=403, detail="Fitur ini hanya untuk akun User (Masyarakat/Pasien).")
return user
# ==============================================================================
# PENGATURAN API FASTAPI
# ==============================================================================
app = FastAPI(title="Agent Diagnosis DBD MySQL", version="3.0.0")
class RegisterRequest(BaseModel):
name: str = Field(..., max_length=255)
email: str = Field(..., max_length=255)
password: str = Field(..., max_length=128)
no_telp: Optional[str] = Field(None, max_length=50)
alamat: Optional[str] = Field(None, max_length=255)
umur: Optional[int] = Field(None, ge=1, le=120)
gender: Optional[str] = Field(None, max_length=50)
class LoginRequest(BaseModel):
email: str
password: str
class UserAdminRequest(BaseModel):
name: str = Field(..., max_length=255)
email: str = Field(..., max_length=255)
password: Optional[str] = Field(None, max_length=128)
role: str = "user"
no_telp: Optional[str] = Field(None, max_length=50)
alamat: Optional[str] = Field(None, max_length=255)
umur: Optional[int] = Field(None, ge=1, le=120)
gender: Optional[str] = Field(None, max_length=50)
class PenyakitRequest(BaseModel):
id_penyakit: str
name: str = Field(..., max_length=255)
deskripsi: Optional[str] = None
solusi: Optional[str] = None
class GejalaRequest(BaseModel):
id_gejala: str
name: str = Field(..., max_length=255)
class AturanRequest(BaseModel):
id_aturan: str
penyakit_kode: str
deskripsi_aturan: Optional[str] = None
kondisi: Dict[str, List[str]]
class GejalaInputRequest(BaseModel):
nama_pasien: str = Field(..., max_length=255)
umur: int = Field(..., ge=1, le=120)
gender: str = Field(..., max_length=50)
gejala: Dict[str, float]
def validasi_password_baru(password: str):
if len(password) < 6:
raise HTTPException(status_code=400, detail="Password minimal 6 karakter.")
@app.get("/", response_class=HTMLResponse)
async def serve_ui():
html_path = Path(__file__).parent / "index.html"
if not html_path.exists():
return HTMLResponse("<h3>File index.html tidak ditemukan</h3>", status_code=404)
return HTMLResponse(content=html_path.read_text(encoding="utf-8"))
# ---------- Registrasi Akun ----------
@app.post("/api/register", status_code=201)
def registrasi_akun(payload: RegisterRequest, db: Session = Depends(get_db)):
nama = teks_wajib(payload.name, "Nama")
email = normalisasi_email(payload.email)
validasi_password_baru(payload.password)
if db.query(TbUser).filter(TbUser.email == email).first():
raise HTTPException(status_code=400, detail="Email sudah terdaftar, silakan gunakan email lain atau login.")
user = TbUser(name=nama, email=email, password=hash_password(payload.password), role="user",
no_telp=teks_opsional(payload.no_telp), alamat=teks_opsional(payload.alamat),
umur=payload.umur, gender=teks_opsional(payload.gender))
db.add(user)
db.commit()
return {"message": "Registrasi berhasil, silakan login.", "user": serialisasi_user(user)}
# ---------- Login (include: Validasi Akun) ----------
@app.post("/api/login")
def login(payload: LoginRequest, db: Session = Depends(get_db)):
email = (payload.email or "").strip().lower()
user = db.query(TbUser).filter(TbUser.email == email).first()
if not user or not verifikasi_password(payload.password, user.password):
raise HTTPException(status_code=401, detail="Email atau password salah.")
# Bersihkan sesi kedaluwarsa
db.query(TbSesi).filter(TbSesi.dibuat < datetime.now() - MASA_BERLAKU_SESI).delete()
token = secrets.token_urlsafe(32)
db.add(TbSesi(token_hash=hash_token(token), user_id=user.id, dibuat=datetime.now()))
db.commit()
return {"token": token, "user": serialisasi_user(user)}
@app.post("/api/logout")
def logout(authorization: Optional[str] = Header(default=None), user: TbUser = Depends(get_current_user), db: Session = Depends(get_db)):
db.query(TbSesi).filter(TbSesi.token_hash == hash_token(authorization[7:].strip())).delete()
db.commit()
return {"status": "logged_out"}
@app.get("/api/me")
def profil_saya(user: TbUser = Depends(get_current_user)):
return serialisasi_user(user)
# ---------- Melihat Informasi Penyakit ----------
@app.get("/api/penyakit")
def get_penyakit(user: TbUser = Depends(get_current_user), db: Session = Depends(get_db)):
kode_per_penyakit = {v: k for k, v in KODE_FUZZY_KE_PENYAKIT.items()}
penyakits = db.query(TbPenyakit).order_by(TbPenyakit.id_penyakit).all()
return {p.id_penyakit: {"id": p.id, "id_penyakit": p.id_penyakit, "nama": p.name, "deskripsi": p.deskripsi,
"solusi": p.solusi, "kode_fuzzy": kode_per_penyakit.get(p.id_penyakit)} for p in penyakits}
@app.get("/api/gejala")
def get_gejala(user: TbUser = Depends(get_current_user), db: Session = Depends(get_db)):
return [{"id": g.id, "kode": g.id_gejala, "nama": g.name} for g in db.query(TbGejala).order_by(TbGejala.id_gejala).all()]
# ---------- Melakukan Diagnosis (include: Proses Perhitungan Fuzzy Mamdani) ----------
@app.post("/api/diagnosa")
def simpan_diagnosa_db(payload: GejalaInputRequest, user: TbUser = Depends(require_user), db: Session = Depends(get_db)):
nama_gejala = {g.id_gejala: g.name for g in db.query(TbGejala).all()}
tidak_dikenal = [k for k in payload.gejala if k not in nama_gejala]
if tidak_dikenal:
raise HTTPException(status_code=400, detail=f"Kode gejala tidak dikenal: {', '.join(tidak_dikenal)}. Muat ulang halaman.")
if any(not (0.0 <= v <= 10.0) for v in payload.gejala.values()):
raise HTTPException(status_code=400, detail="Nilai keparahan gejala harus di antara 0 dan 10.")
aturan_list = aturan_dari_db(db)
if not aturan_list:
raise HTTPException(status_code=400, detail="Basis aturan masih kosong. Hubungi Admin.")
hasil = agent_fuzzy.hitung_diagnosa(payload.gejala, aturan_list)
penyakit_obj, info = info_penyakit(db, hasil["kode_penyakit"])
gejala_detail = [{
"kode": kode,
"nama": nama_gejala.get(kode, kode),
"nilai": nilai,
"label": hasil["fuzzifikasi"][kode]["label"]
} for kode, nilai in sorted(payload.gejala.items())]
detail = {"deskripsi": info["deskripsi"], "gejala": gejala_detail,
"rules_aktif": hasil["rules_aktif"], "agregasi_max": hasil["agregasi_max"]}
new_record = TbDiagnosa(
tanggal=datetime.now().strftime("%d %b %Y, %H:%M:%S"),
nama_pasien=teks_wajib(payload.nama_pasien, "Nama pasien"),
umur=payload.umur,
gender=payload.gender,
kode_penyakit=hasil["kode_penyakit"],
nama_penyakit=info["nama"],
skor_centroid=hasil["skor_centroid"],
solusi=info["solusi"],
detail=json.dumps(detail),
user_id=user.id,
penyakit_id=penyakit_obj.id if penyakit_obj else None
)
db.add(new_record)
db.commit()
db.refresh(new_record)
return serialisasi_diagnosa(new_record, lengkap=True)
# ---------- Melihat / Mengelola Hasil Diagnosis ----------
def query_diagnosa_milik(db: Session, user: TbUser):
q = db.query(TbDiagnosa)
if user.role != "admin":
q = q.filter(TbDiagnosa.user_id == user.id)
return q
@app.get("/api/riwayat")
def get_riwayat_db(user: TbUser = Depends(get_current_user), db: Session = Depends(get_db)):
records = query_diagnosa_milik(db, user).order_by(TbDiagnosa.id.desc()).all()
total = len(records)
if total == 0:
statistik = {"DF": 0.0, "DHF": 0.0, "DSS": 0.0, "total": 0}
else:
c_df = sum(1 for r in records if r.kode_penyakit == "DF")
c_dhf = sum(1 for r in records if r.kode_penyakit == "DHF")
c_dss = sum(1 for r in records if r.kode_penyakit == "DSS")
statistik = {
"DF": round((c_df / total) * 100, 2),
"DHF": round((c_dhf / total) * 100, 2),
"DSS": round((c_dss / total) * 100, 2),
"total": total
}
return {"statistik": statistik, "riwayat": [serialisasi_diagnosa(r) for r in records]}
@app.get("/api/riwayat/{diagnosa_id}")
def detail_riwayat_db(diagnosa_id: int, user: TbUser = Depends(get_current_user), db: Session = Depends(get_db)):
record = query_diagnosa_milik(db, user).filter(TbDiagnosa.id == diagnosa_id).first()
if not record:
raise HTTPException(status_code=404, detail="Data diagnosa tidak ditemukan di database")
return serialisasi_diagnosa(record, lengkap=True)
@app.delete("/api/riwayat/{diagnosa_id}")
def hapus_riwayat_db(diagnosa_id: int, user: TbUser = Depends(get_current_user), db: Session = Depends(get_db)):
record = query_diagnosa_milik(db, user).filter(TbDiagnosa.id == diagnosa_id).first()
if not record:
raise HTTPException(status_code=404, detail="Data diagnosa tidak ditemukan di database")
db.delete(record)
db.commit()
return {"status": "deleted", "id": diagnosa_id}
# ==============================================================================
# ADMIN: MENGELOLA DATA
# ==============================================================================
@app.get("/api/admin/ringkasan")
def ringkasan_admin(admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
return {
"user": db.query(TbUser).filter(TbUser.role == "user").count(),
"admin": db.query(TbUser).filter(TbUser.role == "admin").count(),
"penyakit": db.query(TbPenyakit).count(),
"gejala": db.query(TbGejala).count(),
"aturan": db.query(TbAturan).count(),
"diagnosa": db.query(TbDiagnosa).count()
}
# ---------- Mengelola Data User ----------
@app.get("/api/admin/users")
def daftar_user(admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
return [serialisasi_user(u) for u in db.query(TbUser).order_by(TbUser.role, TbUser.name).all()]
def terapkan_data_user(u: TbUser, payload: UserAdminRequest, db: Session):
email = normalisasi_email(payload.email)
if payload.role not in ("admin", "user"):
raise HTTPException(status_code=400, detail="Role harus 'admin' atau 'user'.")
duplikat = db.query(TbUser).filter(TbUser.email == email, TbUser.id != (u.id or 0)).first()
if duplikat:
raise HTTPException(status_code=400, detail="Email sudah dipakai akun lain.")
u.name = teks_wajib(payload.name, "Nama")
u.email = email
u.role = payload.role
u.no_telp = teks_opsional(payload.no_telp)
u.alamat = teks_opsional(payload.alamat)
u.umur = payload.umur
u.gender = teks_opsional(payload.gender)
if payload.password:
validasi_password_baru(payload.password)
u.password = hash_password(payload.password)
@app.post("/api/admin/users", status_code=201)
def tambah_user(payload: UserAdminRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
if not payload.password:
raise HTTPException(status_code=400, detail="Password wajib diisi untuk akun baru.")
u = TbUser()
terapkan_data_user(u, payload, db)
db.add(u)
db.commit()
return serialisasi_user(u)
@app.put("/api/admin/users/{user_id}")
def ubah_user(user_id: int, payload: UserAdminRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
u = db.get(TbUser, user_id)
if not u:
raise HTTPException(status_code=404, detail="User tidak ditemukan.")
if u.id == admin.id and payload.role != "admin":
raise HTTPException(status_code=400, detail="Anda tidak dapat menurunkan role akun Anda sendiri.")
terapkan_data_user(u, payload, db)
db.commit()
return serialisasi_user(u)
@app.delete("/api/admin/users/{user_id}")
def hapus_user(user_id: int, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
u = db.get(TbUser, user_id)
if not u:
raise HTTPException(status_code=404, detail="User tidak ditemukan.")
if u.id == admin.id:
raise HTTPException(status_code=400, detail="Anda tidak dapat menghapus akun Anda sendiri.")
db.query(TbSesi).filter(TbSesi.user_id == u.id).delete()
# Riwayat diagnosis tetap disimpan, hanya dilepas dari akun yang dihapus
db.query(TbDiagnosa).filter(TbDiagnosa.user_id == u.id).update({TbDiagnosa.user_id: None})
db.delete(u)
db.commit()
return {"status": "deleted", "id": user_id}
# ---------- Mengelola Data Penyakit ----------
@app.post("/api/admin/penyakit", status_code=201)
def tambah_penyakit(payload: PenyakitRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
kode = normalisasi_kode(payload.id_penyakit, "Kode penyakit")
if db.query(TbPenyakit).filter(TbPenyakit.id_penyakit == kode).first():
raise HTTPException(status_code=400, detail=f"Kode penyakit {kode} sudah ada.")
p = TbPenyakit(id_penyakit=kode, name=teks_wajib(payload.name, "Nama penyakit"),
deskripsi=teks_opsional(payload.deskripsi), solusi=teks_opsional(payload.solusi))
db.add(p)
db.commit()
return {"id": p.id}
@app.put("/api/admin/penyakit/{penyakit_id}")
def ubah_penyakit(penyakit_id: int, payload: PenyakitRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
p = db.get(TbPenyakit, penyakit_id)
if not p:
raise HTTPException(status_code=404, detail="Data penyakit tidak ditemukan.")
kode = normalisasi_kode(payload.id_penyakit, "Kode penyakit")
if kode != p.id_penyakit:
if p.id_penyakit in KODE_FUZZY_KE_PENYAKIT.values():
raise HTTPException(status_code=400, detail=f"Kode {p.id_penyakit} terhubung ke output fuzzy dan tidak dapat diubah.")
if db.query(TbPenyakit).filter(TbPenyakit.id_penyakit == kode).first():
raise HTTPException(status_code=400, detail=f"Kode penyakit {kode} sudah ada.")
p.id_penyakit = kode
p.name = teks_wajib(payload.name, "Nama penyakit")
p.deskripsi = teks_opsional(payload.deskripsi)
p.solusi = teks_opsional(payload.solusi)
db.commit()
return {"id": p.id}
@app.delete("/api/admin/penyakit/{penyakit_id}")
def hapus_penyakit(penyakit_id: int, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
p = db.get(TbPenyakit, penyakit_id)
if not p:
raise HTTPException(status_code=404, detail="Data penyakit tidak ditemukan.")
if p.id_penyakit in KODE_FUZZY_KE_PENYAKIT.values():
raise HTTPException(status_code=400, detail=f"{p.name} dipakai sebagai output mesin inferensi fuzzy dan tidak dapat dihapus.")
db.query(TbDiagnosa).filter(TbDiagnosa.penyakit_id == p.id).update({TbDiagnosa.penyakit_id: None})
db.delete(p)
db.commit()
return {"status": "deleted", "id": penyakit_id}
# ---------- Mengelola Data Gejala ----------
@app.post("/api/admin/gejala", status_code=201)
def tambah_gejala(payload: GejalaRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
kode = normalisasi_kode(payload.id_gejala, "Kode gejala")
if db.query(TbGejala).filter(TbGejala.id_gejala == kode).first():
raise HTTPException(status_code=400, detail=f"Kode gejala {kode} sudah ada.")
g = TbGejala(id_gejala=kode, name=teks_wajib(payload.name, "Nama gejala"))
db.add(g)
db.commit()
return {"id": g.id}
@app.put("/api/admin/gejala/{gejala_id}")
def ubah_gejala(gejala_id: int, payload: GejalaRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
g = db.get(TbGejala, gejala_id)
if not g:
raise HTTPException(status_code=404, detail="Data gejala tidak ditemukan.")
kode_baru = normalisasi_kode(payload.id_gejala, "Kode gejala")
if kode_baru != g.id_gejala:
if db.query(TbGejala).filter(TbGejala.id_gejala == kode_baru).first():
raise HTTPException(status_code=400, detail=f"Kode gejala {kode_baru} sudah ada.")
# Perbarui kode gejala di semua aturan yang memakainya
for a in db.query(TbAturan).all():
kondisi = baca_json(a.kondisi, {})
if g.id_gejala in kondisi:
kondisi[kode_baru] = kondisi.pop(g.id_gejala)
a.kondisi = json.dumps(kondisi)
g.id_gejala = kode_baru
g.name = teks_wajib(payload.name, "Nama gejala")
db.commit()
return {"id": g.id}
@app.delete("/api/admin/gejala/{gejala_id}")
def hapus_gejala(gejala_id: int, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
g = db.get(TbGejala, gejala_id)
if not g:
raise HTTPException(status_code=404, detail="Data gejala tidak ditemukan.")
dipakai = [a.id_aturan for a in db.query(TbAturan).all() if g.id_gejala in baca_json(a.kondisi, {})]
if dipakai:
raise HTTPException(status_code=400, detail=f"Gejala {g.id_gejala} masih dipakai pada aturan {', '.join(sorted(dipakai))}. Ubah aturan tersebut terlebih dahulu.")
db.delete(g)
db.commit()
return {"status": "deleted", "id": gejala_id}
# ---------- Mengelola Data Aturan Fuzzy ----------
@app.get("/api/admin/aturan")
def daftar_aturan(admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
return aturan_dari_db(db)
def validasi_aturan(payload: AturanRequest, db: Session) -> dict:
if payload.penyakit_kode not in KODE_FUZZY:
raise HTTPException(status_code=400, detail=f"Output aturan harus salah satu dari: {', '.join(KODE_FUZZY)}.")
kode_gejala = {g.id_gejala for g in db.query(TbGejala).all()}
kondisi = {}
for kode, daftar in payload.kondisi.items():
daftar = [h for h in HIMPUNAN if h in daftar]
if not daftar:
continue
if kode not in kode_gejala:
raise HTTPException(status_code=400, detail=f"Kode gejala {kode} tidak ada di data gejala.")
kondisi[kode] = daftar
if not kondisi:
raise HTTPException(status_code=400, detail="Aturan harus memiliki minimal satu kondisi gejala.")
return kondisi
@app.post("/api/admin/aturan", status_code=201)
def tambah_aturan(payload: AturanRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
kode = normalisasi_kode(payload.id_aturan, "Kode aturan")
if db.query(TbAturan).filter(TbAturan.id_aturan == kode).first():
raise HTTPException(status_code=400, detail=f"Kode aturan {kode} sudah ada.")
a = TbAturan(id_aturan=kode, penyakit_kode=payload.penyakit_kode,
deskripsi_aturan=teks_opsional(payload.deskripsi_aturan),
kondisi=json.dumps(validasi_aturan(payload, db)))
db.add(a)
db.commit()
return {"id": a.id}
@app.put("/api/admin/aturan/{aturan_id}")
def ubah_aturan(aturan_id: int, payload: AturanRequest, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
a = db.get(TbAturan, aturan_id)
if not a:
raise HTTPException(status_code=404, detail="Data aturan tidak ditemukan.")
kode = normalisasi_kode(payload.id_aturan, "Kode aturan")
if kode != a.id_aturan and db.query(TbAturan).filter(TbAturan.id_aturan == kode).first():
raise HTTPException(status_code=400, detail=f"Kode aturan {kode} sudah ada.")
kondisi = validasi_aturan(payload, db)
a.id_aturan = kode
a.penyakit_kode = payload.penyakit_kode
a.deskripsi_aturan = teks_opsional(payload.deskripsi_aturan)
a.kondisi = json.dumps(kondisi)
db.commit()
return {"id": a.id}
@app.delete("/api/admin/aturan/{aturan_id}")
def hapus_aturan(aturan_id: int, admin: TbUser = Depends(require_admin), db: Session = Depends(get_db)):
a = db.get(TbAturan, aturan_id)
if not a:
raise HTTPException(status_code=404, detail="Data aturan tidak ditemukan.")
db.delete(a)
db.commit()
return {"status": "deleted", "id": aturan_id}
if __name__ == "__main__":
uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)